Exemple #1
0
        /// <summary>
        /// たくさんボタンを作る、ボタンが重ならなように使用側で調節
        /// </summary>
        /// <param name="layer">追加レイヤー</param>
        /// <param name="text">テキストのArray</param>
        /// <param name="UpSpace">上の間隔</param>
        /// <param name="DownSpace">下の間隔</param>
        /// <param name="leftSpace">左の間隔</param>
        /// <param name="rightSpace">右の間隔</param>
        /// <param name="buttonWideSpace">ボタンの間の横間隔</param>
        /// <param name="buttonHeightSpace">ボタンの間の縦間隔</param>
        /// <returns></returns>
        public static void MakeButtonArray(asd.Layer2D layer, string[,] texts, int UpSpace, int DownSpace, int leftSpace, int rightSpace, int buttonWideSpace, int buttonHeightSpace, int fontSize)
        {
            MaxRow = texts.GetLength(0);                                          //縦の個数
            MaxCol = texts.GetLength(1);
            var width        = asd.Engine.WindowSize.X - leftSpace - rightSpace;  //この物体のX幅
            var height       = asd.Engine.WindowSize.Y - UpSpace - DownSpace;
            var buttonWidth  = (width - (MaxCol - 1) * buttonWideSpace) / MaxCol; //1つのボタン幅
            var buttonHeight = (height - (MaxRow - 1) * buttonHeightSpace) / MaxRow;

            Buttons = new Button[MaxRow, MaxCol];
            for (int row = 0; row < MaxRow; row++)
            {
                for (int column = 0; column < MaxCol; column++)
                {
                    Buttons[row, column] = new Button(texts[row, column], new asd.Vector2DF(column * (buttonWidth + buttonWideSpace) + buttonWidth / 2 + leftSpace, row * (buttonHeight + buttonHeightSpace) + buttonHeight / 2 + UpSpace), buttonWidth, buttonHeight, fontSize);
                }
            }
            MaxRow--;//個数だと使いずらいから0からのカウントに調節
            MaxCol--;
            CurrentRow = 0;
            CurrentCol = 0;
            ChangeCurrentButton(0, 0);
            foreach (var b in Buttons)
            {
                layer.AddObject(b);
            }
        }
        protected override void OnRegistered()
        {
            asd.Layer2D layerpict = new asd.Layer2D();
            layerpict.DrawingPriority = -10;
            AddLayer(layerpict);

            asd.Layer2D layertext = new asd.Layer2D();
            AddLayer(layertext);

            asd.TextureObject2D background = new asd.TextureObject2D();
            background.Texture = asd.Engine.Graphics.CreateTexture2D("Resources/Over.png");

            layerpict.AddObject(background);

            // フォントを生成する。
            var font = asd.Engine.Graphics.CreateFont("font.aff");

            // 文字描画オブジェクトを生成する。
            var obj = new asd.TextObject2D();

            // 描画に使うフォントを設定する。
            obj.Font = font;

            // 描画位置を指定する。
            obj.Position = new asd.Vector2DF(220, 240);

            Singleton.Getsingleton();
            // 描画する文字列を指定する。
            obj.Text = "SCORE:" + Singleton.singleton.score;

            // 文字描画オブジェクトのインスタンスをエンジンへ追加する。
            layertext.AddObject(obj);
        }
Exemple #3
0
    public void Run()
    {
        // Altseedを初期化する。
        asd.Engine.Initialize("CustomPostEffect_Invert", 640, 480, new asd.EngineOption());

        // シーン、レイヤー、画像を表示するオブジェクトを生成する。
        var scene = new asd.Scene();
        var layer = new asd.Layer2D();
        var obj   = new asd.TextureObject2D();

        obj.Texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Picture1.png");

        // シーンを変更し、そのシーンにレイヤーを追加し、そのレイヤーにオブジェクトを追加する。
        asd.Engine.ChangeScene(scene);
        scene.AddLayer(layer);
        layer.AddObject(obj);

        // レイヤーにポストエフェクトを適用する。
        layer.AddPostEffect(new InvertPostEffect());

        while (asd.Engine.DoEvents())
        {
            asd.Engine.Update();
            Recorder.TakeScreenShot("CustomPostEffect_Invert", 5);
        }

        asd.Engine.Terminate();
    }
 public EventManager(asd.Scene scene)
 {
     this.scene = scene;
     List<asd.Layer> layers = scene.Layers.ToList();
     mainLayer = layers[0] as asd.Layer2D;
     subLayer = layers[1] as asd.Layer2D;
 }
Exemple #5
0
        protected override void OnRegistered()
        {
            base.OnRegistered();
            asd.Layer2D layer = new asd.Layer2D();
            AddLayer(layer);
            //asd.TextureObject2D background = new asd.TextureObject2D();
            //background.Texture = asd.Engine.Graphics.CreateTexture2D("Resources/Title.png");
            //layer.AddObject(background);
            Player player = new Player();

            playerInfo = player;
            layer.AddObject(player);
            enemySpornCount = 0;
            //StraightMoveEnemy straightMoveEnemy = new StraightMoveEnemy(new asd.Vector2DF(400.0f, 340.0f), new asd.Vector2DF(1.0f, 0.0f), playerInfo);
            NomalEnemy nomalEnemy = new NomalEnemy(new asd.Vector2DF(400.0f, 340.0f), new asd.Vector2DF(0.0f, 0.0f), playerInfo);

            //WavyAttackEnemy wavyAttackEnemy = new WavyAttackEnemy(new asd.Vector2DF(400.0f, 340.0f), new asd.Vector2DF(0.0f, 0.0f), playerInfo);
            //ReciprocateEnemy reciprocateEnemy = new ReciprocateEnemy(new asd.Vector2DF(400.0f, 340.0f), new asd.Vector2DF(0.0f, 0.0f), playerInfo);
            layer.AddObject(nomalEnemy);
            asd.Font         font       = asd.Engine.Graphics.CreateDynamicFont("", 24, new asd.Color(255, 255, 255), 1, new asd.Color(255, 255, 255));
            asd.TextObject2D textObject = new asd.TextObject2D();
            textObject.Font     = font;
            textObject.Text     = "おやすみなさい";
            textObject.Position = new asd.Vector2DF(255, 255);
            //layer.AddObject(textObject);
        }
Exemple #6
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var obj = new asd.MapObject2D();

            Assert.AreNotEqual<asd.Scene>(scene, null);
            Assert.AreNotEqual<asd.Layer>(layer, null);
            Assert.AreNotEqual<asd.MapObject2D>(obj, null);

            asd.Engine.ChangeScene(scene);
            scene.AddLayer(layer);
            layer.AddObject(obj);

            var g = asd.Engine.Graphics;
            var texture = g.CreateTexture2D("Data/Map/MapTest.png");

            var chip1 = new asd.Chip2D();
            chip1.Texture = texture;
            chip1.Position = new asd.Vector2DF(0, 0);
            obj.AddChip(chip1);

            var chip2 = new asd.Chip2D();
            chip2.Texture = texture;
            chip2.Position = new asd.Vector2DF(300, 0);
            obj.AddChip(chip2);

            obj.Position = new asd.Vector2DF(0, 0);
        }
    public void Run()
    {
        // Altseedを初期化する。
        asd.Engine.Initialize("CustomPostEffect_Invert", 640, 480, new asd.EngineOption());

        // シーン、レイヤー、画像を表示するオブジェクトを生成する。
        var scene = new asd.Scene();
        var layer = new asd.Layer2D();
        var obj = new asd.TextureObject2D();
        obj.Texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Picture1.png");

        // シーンを変更し、そのシーンにレイヤーを追加し、そのレイヤーにオブジェクトを追加する。
        asd.Engine.ChangeScene(scene);
        scene.AddLayer(layer);
        layer.AddObject(obj);

        // レイヤーにポストエフェクトを適用する。
        layer.AddPostEffect(new InvertPostEffect());

        while (asd.Engine.DoEvents())
        {
            asd.Engine.Update();
            Recorder.TakeScreenShot("CustomPostEffect_Invert", 5);
        }

        asd.Engine.Terminate();
    }
Exemple #8
0
 public void CloseDialog(asd.Layer2D layer)
 {
     layer.RemoveObject(_dialog);
     layer.RemoveObject(_valueText);
     layer.RemoveObject(_okButton);
     layer.RemoveObject(_cancelButton);
 }
Exemple #9
0
        protected override void OnRegistered()
        {
            layer = new asd.Layer2D();
            AddLayer(layer);

            var titleImage = new asd.TextureObject2D
            {
                Texture = asd.Engine.Graphics.CreateTexture2D("Title.png")
            };

            layer.AddObject(titleImage);

            // Play BGM
            // 音声ファイルを読み込む。BGMの場合、第2引数を false に設定することで、再生しながらファイルを解凍することが推奨されている。
            asd.SoundSource bgm1 = asd.Engine.Sound.CreateSoundSource("Mixdown.ogg", false);

            // 音声のループを有効にする。
            bgm1.IsLoopingMode = true;

            // 音声のループ始端を1秒に、ループ終端を6秒に設定する。
            bgm1.LoopStartingPoint = 4f;
            bgm1.LoopEndPoint      = bgm1.Length;

            // 音声を再生する。
            int id_bgm1 = asd.Engine.Sound.Play(bgm1);
        }
Exemple #10
0
        protected override void OnRegistered()
        {
            EasyMode        = false;
            HardMode        = false;
            StartSound      = asd.Engine.Sound.CreateSoundSource("Click1.wav", true);
            TitleText       = new asd.TextObject2D();
            EnterText       = new asd.TextObject2D();
            Increasing      = false;
            IsSceneChanging = false;

            asd.Layer2D layer = new asd.Layer2D();
            AddLayer(layer);
            asd.TextureObject2D backGround = new asd.TextureObject2D();
            backGround.Texture = asd.Engine.Graphics.CreateTexture2D("Title.png");
            backGround.Color   = new asd.Color(255, 255, 255, 80);

            TitleText.Font        = asd.Engine.Graphics.CreateDynamicFont("font.ttf", 90, FontColor, 1, new asd.Color(0, 0, 0, 255));
            TitleText.LineSpacing = 20f;
            TitleText.Position    = new asd.Vector2DF(50, 20);
            TitleText.Text        = "ぼうえいせん!";

            EnterText.Font     = asd.Engine.Graphics.CreateDynamicFont("font.ttf", 55, FontColor, 1, new asd.Color(0, 0, 0, 255));
            EnterText.Position = new asd.Vector2DF(50, 550);
            EnterText.Text     = "クリックでスタート\n \n※Zボタンでかんたんモード";

            layer.AddObject(backGround);
            layer.AddObject(TitleText);
            layer.AddObject(EnterText);
            base.OnRegistered();
        }
Exemple #11
0
        protected override void OnRegistered()
        {
            layer = new asd.Layer2D();
            AddLayer(layer);

            // 下地
            var background = new asd.GeometryObject2D();

            layer.AddObject(background);
            var bgRect = new asd.RectangleShape();

            bgRect.DrawingArea = new asd.RectF(0, 0, 1800, 1000);
            background.Shape   = bgRect;

            foreach (var c in gameData.Battle.GetAliveCityList())
            {
                var maps = c.GetMaps();
                foreach (var m in maps)
                {
                    m.AddLayer(layer);
                }
            }

            var info = Singleton.InfomationWindow;

            info.AddLayer(layer);
            var info2 = Singleton.GameProcessInfomation;

            info2.AddLayer(layer);
        }
Exemple #12
0
        public CharacterImageEditor(string path = "")
        {
            Path      = path;
            MainLayer = new asd.Layer2D();

            Character = new EditableCharacterImage();
            if (path != "")
            {
                _ = Character.LoadCharacterImageIOAsync(path);
            }
            MainLayer.AddObject(Character);

            MainCamera = new asd.CameraObject2D();
            var size = Character.BaseImage?.Size ?? default;

            MainCamera.Src = new asd.RectI(new asd.Vector2DI(), size);
            if (size.X != 0 && size.Y != 0)
            {
                if ((float)asd.Engine.WindowSize.X / asd.Engine.WindowSize.Y >= 1.0f / 2)
                {
                    MainCamera.Dst = new asd.RectI((asd.Engine.WindowSize.X - size.X * asd.Engine.WindowSize.Y / size.Y) / 2,
                                                   0, size.X * asd.Engine.WindowSize.Y / size.Y, asd.Engine.WindowSize.Y);
                }
                else
                {
                    MainCamera.Dst = new asd.RectI(0, (asd.Engine.WindowSize.Y - size.Y * asd.Engine.WindowSize.X / size.X) / 2,
                                                   asd.Engine.WindowSize.X, size.Y * asd.Engine.WindowSize.X / size.X);
                }
            }
            MainLayer.AddObject(MainCamera);
            AddLayer(MainLayer);
        }
Exemple #13
0
        protected override void OnRegistered()
        {
            Click = asd.Engine.Sound.CreateSoundSource("Click2.wav", true);

            asd.Layer2D layer = new asd.Layer2D();
            AddLayer(layer);
            asd.TextureObject2D backGround = new asd.TextureObject2D();
            backGround.Texture = asd.Engine.Graphics.CreateTexture2D("Gameover.png");
            backGround.Color   = new asd.Color(255, 255, 255, 200);

            TitleText.Font     = asd.Engine.Graphics.CreateDynamicFont("font.ttf", 90, FontColor, 1, new asd.Color(0, 0, 0, 255));
            TitleText.Position = new asd.Vector2DF(80, 20);
            TitleText.Text     = "げーむおーばー";

            StageText.Font     = asd.Engine.Graphics.CreateDynamicFont("font.ttf", 45, FontColor, 1, new asd.Color(0, 0, 0, 255));
            StageText.Position = new asd.Vector2DF(400, 150);
            StageText.Text     = "ステージ" + GameScene.Stage + "到達!!";

            EnterText.Font     = asd.Engine.Graphics.CreateDynamicFont("font.ttf", 70, FontColor, 1, new asd.Color(0, 0, 0, 255));
            EnterText.Position = new asd.Vector2DF(120, 700);
            EnterText.Text     = "クリックでタイトル";

            layer.AddObject(backGround);
            layer.AddObject(TitleText);
            layer.AddObject(EnterText);
            layer.AddObject(StageText);
            base.OnRegistered();
        }
Exemple #14
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var obj   = new asd.MapObject2D();

            Assert.AreNotEqual <asd.Scene>(scene, null);
            Assert.AreNotEqual <asd.Layer>(layer, null);
            Assert.AreNotEqual <asd.MapObject2D>(obj, null);

            asd.Engine.ChangeScene(scene);
            scene.AddLayer(layer);
            layer.AddObject(obj);

            var g       = asd.Engine.Graphics;
            var texture = g.CreateTexture2D("Data/Map/MapTest.png");

            var chip1 = new asd.Chip2D();

            chip1.Texture  = texture;
            chip1.Position = new asd.Vector2DF(0, 0);
            obj.AddChip(chip1);

            var chip2 = new asd.Chip2D();

            chip2.Texture  = texture;
            chip2.Position = new asd.Vector2DF(300, 0);
            obj.AddChip(chip2);

            obj.Position = new asd.Vector2DF(0, 0);
        }
            protected override void OnUpdated()
            {
                // フレーム数を数える。
                count++;

                // 60フレームごとにレイヤーを追加する処理
                if (count % 60 == 0)
                {
                    // レイヤークラスのインスタンスを生成する。
                    var layer = new asd.Layer2D();

                    // 描画するレイヤーをシーンに追加する。
                    AddLayer(layer);

                    // オブジェクトを生成する。
                    var obj = new asd.TextureObject2D();

                    // オブジェクトに画像を設定する。
                    obj.Texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Picture1.png");

                    // オブジェクトの位置を設定する。
                    var p = count / 60 * 20;
                    obj.Position = new asd.Vector2DF(p, p);

                    // オブジェクトをレイヤーに追加する。
                    layer.AddObject(obj);
                }
            }
        public DelaunayTriangles(List <Point> pointList, asd.Layer2D layer, asd.Vector2DF N, Dungeon dungeon)
        {
            this.layer   = layer;
            this.range   = N;
            this.dungeon = dungeon;

            DelaunayTriangulation(pointList);
        }
Exemple #17
0
        public EventManager(asd.Scene scene)
        {
            this.scene = scene;
            List <asd.Layer> layers = scene.Layers.ToList();

            mainLayer = layers[0] as asd.Layer2D;
            subLayer  = layers[1] as asd.Layer2D;
        }
Exemple #18
0
 public void ShowDialog(asd.Layer2D layer, string cityName)
 {
     layer.AddObject(_dialog);
     _valueText.Text = cityName + "でよろしいですか?";
     layer.AddObject(_valueText);
     layer.AddObject(_okButton);
     layer.AddObject(_cancelButton);
 }
 /// <summary>
 /// レイヤーがシーンに登録されたときに実行されるイベントを追加する。
 /// </summary>
 /// <exception cref="ArgumentNullException"></exception>
 public static void AddOnAddedEvent(this asd.Layer2D layer, Action action)
 {
     if (action == null)
     {
         throw new ArgumentNullException("action");
     }
     layer.GetLayer2DComponent().OnAddedEvent += _ => action();
 }
        protected override void OnRegistered()
        {
            // 2Dを表示するレイヤーのインスタンスを生成する。
            gameLayer = new asd.Layer2D();
            asd.Layer2D backgroundLayer = new asd.Layer2D();
            uiLayer = new asd.Layer2D();

            // レイヤーの描画優先度を設定する(デフォルトで0)
            backgroundLayer.DrawingPriority = -10;


            // シーンにレイヤーのインスタンスを追加する。
            AddLayer(gameLayer);
            AddLayer(backgroundLayer);
            AddLayer(uiLayer);

            // Background オブジェクトを生成する。ここで画像のパスを設定します。
            MovingBackground bg1 = new MovingBackground(new asd.Vector2DF(0.0f, 0.0f), "Game_Bg.png", 1.0f);
            MovingBackground bg2 = new MovingBackground(new asd.Vector2DF(0.0f, -bg1.Texture.Size.Y), "Game_Bg.png", 1.0f);
            // 赤い背景を生成する。
            MovingBackground bgRed1 = new MovingBackground(new asd.Vector2DF(-2.0f, 30.0f), "Game_Bg_Red.png", 0.5f);
            MovingBackground bgRed2 = new MovingBackground(new asd.Vector2DF(-2.0f, 30.0f - bgRed1.Texture.Size.Y), "Game_Bg_Red.png", 0.5f);

            // 黄色い背景を生成する。
            MovingBackground bgYellow1 = new MovingBackground(new asd.Vector2DF(-10.0f, 80.0f), "Game_Bg_Yellow.png", 1.0f);
            MovingBackground bgYellow2 = new MovingBackground(new asd.Vector2DF(-10.0f, 80.0f - bgRed1.Texture.Size.Y), "Game_Bg_Yellow.png", 1.0f);

            // 背景を背景レイヤーに追加する。
            backgroundLayer.AddObject(bg1);
            backgroundLayer.AddObject(bg2);
            backgroundLayer.AddObject(bgRed1);
            backgroundLayer.AddObject(bgRed2);
            backgroundLayer.AddObject(bgYellow1);
            backgroundLayer.AddObject(bgYellow2);

            // プレイヤーのインスタンスを生成する。
            player = new Player();

            // プレイヤーのインスタンスをレイヤーに追加する。
            gameLayer.AddObject(player);

            // レイヤーにスコアのインスタンスを追加する。
            var score = new Score();

            uiLayer.AddObject(score);

            // stage を初期化する
            initAllStage();

            // BGMを読み込む。
            bgm = asd.Engine.Sound.CreateSoundSource("Bgm.ogg", false);

            // BGMがループするように設定する。
            bgm.IsLoopingMode = true;

            // BGMは流れていないのでIDはnull
            playingBgmId = null;
        }
Exemple #21
0
        protected override void OnRegistered()
        {
            // 2Dを表示するレイヤーのインスタンスを生成する。
            headLayer = new asd.Layer2D();

            // シーンにレイヤーのインスタンスを追加する。
            AddLayer(headLayer);
            Console.WriteLine("OK");
        }
Exemple #22
0
        protected override void OnRegistered()
        {
            asd.Layer2D layer = new asd.Layer2D();
            AddLayer(layer);
            Player player = new Player();

            layer.AddObject(player);
            base.OnRegistered();
        }
Exemple #23
0
 protected override void OnRegistered()
 {
     asd.Layer2D layer = new asd.Layer2D();
     AddLayer(layer);
     layer.AddObject(new BackGround());
     layer.AddObject(new GeneralText(new asd.Vector2DF(asd.Engine.WindowSize.X / 2, 2 * Program.CellLarge), "Clear", 100, new asd.Color(2, 20, 20, 200), 5, new asd.Color(222, 222, 222, 200)));
     layer.AddObject(new GeneralText(new asd.Vector2DF(asd.Engine.WindowSize.X / 2, 16 * Program.CellLarge), "enterキーでタイトルへ", 50, new asd.Color(2, 20, 20, 200), 2, new asd.Color(222, 222, 222, 200)));
     layer.AddObject(new GeneralText(new asd.Vector2DF(asd.Engine.WindowSize.X / 2, 5 * Program.CellLarge), "総移動数" + TotalMove, 40, new asd.Color(2, 20, 20, 200), 2, new asd.Color(222, 222, 222, 200)));
 }
Exemple #24
0
 protected override void OnRegistered()
 {
     asd.Layer2D layer = new asd.Layer2D();
     AddLayer(layer);
     asd.TextureObject2D background = new asd.TextureObject2D();
     background.Texture = asd.Engine.Graphics.CreateTexture2D("Resources/Title.png");
     layer.AddObject(background);
     base.OnRegistered();
 }
Exemple #25
0
        public Player(asd.Layer2D layer)
        {
            Texture        = asd.Engine.Graphics.CreateTexture2D("Resource/myship.png");
            Scale          = new asd.Vector2DF(2, 2);
            CenterPosition = Texture.Size.To2DF() / 2;
            Position       = Resource.Window.Size.To2DF() / 2;

            gameLayer = layer;
        }
Exemple #26
0
        public Title()
        {
            var layer = new asd.Layer2D();
            var bg    = new asd.TextureObject2D();

            bg.Texture = asd.Engine.Graphics.CreateTexture2D("Resource/title.png");
            layer.AddObject(bg);
            AddLayer(layer);
        }
Exemple #27
0
        public Enemy(asd.Layer2D layer, char wordtype)
        {
            Texture        = asd.Engine.Graphics.CreateTexture2D("Resource/enemy_Z.png");
            Scale          = new asd.Vector2DF(Size.X / Texture.Size.X / 2, Size.Y / Texture.Size.Y / 2);
            CenterPosition = Texture.Size.To2DF() / 2;
            Position       = new asd.Vector2DF(targetPositionA.X, -Size.Y);

            gameLayer     = layer;
            this.wordtype = wordtype;
        }
Exemple #28
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            layer = new asd.Layer2D();
            obj = new asd.TextureObject2D();

            asd.Engine.ChangeScene(scene);
            scene.AddLayer(layer);
            layer.AddObject(obj);
        }
Exemple #29
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();

            layer = new asd.Layer2D();
            obj   = new asd.TextureObject2D();

            asd.Engine.ChangeScene(scene);
            scene.AddLayer(layer);
            layer.AddObject(obj);
        }
Exemple #30
0
        public GameOver()
        {
            var layer = new asd.Layer2D();

            var background = new asd.TextureObject2D();

            background.Texture = asd.Engine.Graphics.CreateTexture2D("gameover.png");
            layer.AddObject(background);

            AddLayer(layer);
        }
Exemple #31
0
        public Clear()
        {
            var layer = new asd.Layer2D();

            var background = new asd.TextureObject2D();

            background.Texture = asd.Engine.Graphics.CreateTexture2D("Resource/clear.png");
            layer.AddObject(background);

            AddLayer(layer);
        }
Exemple #32
0
        public Enemy(asd.Layer2D layer, char wordtype, asd.Vector2DF pos, EnemyShot.Type t)
        {
            Texture        = asd.Engine.Graphics.CreateTexture2D("Resource/game_enemy/enemy_" + wordtype + ".png");
            Scale          = new asd.Vector2DF(Size.X / Texture.Size.X / 2, Size.Y / Texture.Size.Y / 2);
            CenterPosition = Texture.Size.To2DF() / 2;
            Position       = new asd.Vector2DF(pos.X, -pos.Y);

            gameLayer     = layer;
            this.wordtype = wordtype;
            typ           = t;
        }
Exemple #33
0
        public void Draw(asd.Layer2D layer)
        {
            var poss = new Point[3] {
                p1, p2, p3
            };

            for (int index = 0; index < 3; index++)
            {
                var line = new Line(poss[index], poss[(index + 1) % 3]);
                layer.AddObject(line);
            }
        }
Exemple #34
0
        protected override void OnRegistered()
        {
            layer = new asd.Layer2D();
            AddLayer(layer);

            var gameoverImage = new asd.TextureObject2D
            {
                Texture = asd.Engine.Graphics.CreateTexture2D("Over.png")
            };

            layer.AddObject(gameoverImage);
        }
Exemple #35
0
        public Scene1()
        {
            //レイヤーを追加する。
            var layer = new asd.Layer2D();
            AddLayer(layer);

            //Sample1.pngを描画するテクスチャオブジェクトを設定する。
            obj = new asd.TextureObject2D();
            obj.Texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Sample1.png");
            obj.CenterPosition = new asd.Vector2DF(256, 256);
            obj.Position = new asd.Vector2DF(320, 240);
            layer.AddObject(obj);
        }
        // レイヤーにライトブルームのポストエフェクトを適用する。
        public void Run()
        {
            // Altseedを初期化する。
            asd.Engine.Initialize("PostEffect_LightBloom", 640, 480, new asd.EngineOption());

            var texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Picture1.png");

            // シーンクラスのインスタンスを生成する。
            var scene = new asd.Scene();

            // レイヤーのコンストラクタを呼び出す。
            var layer = new asd.Layer2D();

            // レイヤークラスのインスタンスを生成する。
            var obj = new asd.TextureObject2D();

            // 画像描画オブジェクトのインスタンスを生成する。
            obj.Position = new asd.Vector2DF(50, 50);
            obj.Texture = texture;

            // シーンを変更し、そのシーンにレイヤーを追加し、そのレイヤーにオブジェクトを追加する。
            asd.Engine.ChangeScene(scene);
            scene.AddLayer(layer);
            layer.AddObject(obj);

            // ライトブルームクラスのインスタンスを生成する。
            var posteffect = new asd.PostEffectLightBloom();

            // ライトブルームのぼかしの強さを設定する。
            posteffect.Intensity = 10.0f;

            // ライトブルームの露光の強さを設定する。
            posteffect.Exposure = 1.0f;

            // ライトブルームで光らせる明るさのしきい値を設定する。
            posteffect.Threshold = 0.3f;

            // レイヤーにライトブルームのポストエフェクトを適用。
            layer.AddPostEffect(posteffect);

            // Altseedのウインドウが閉じられていないか確認する。
            while (asd.Engine.DoEvents())
            {
                // Altseedを更新する。
                asd.Engine.Update();
            }

            // Altseedを終了する。
            asd.Engine.Terminate();
        }
Exemple #37
0
        // フェードアウト・フェードインでシーン遷移をするサンプル。
        public void Run()
        {
            // Altseedを初期化する。
            asd.Engine.Initialize("Transition_Fade", 640, 480, new asd.EngineOption());

            // シーン(1)、レイヤー、オブジェクトのインスタンスを生成する。
            var scene1 = new asd.Scene();
            var layer1 = new asd.Layer2D();
            var object1 = new asd.TextureObject2D();

            // 画像を読み込み、オブジェクトに設定する。
            var texture1 = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Scene1.png");
            object1.Texture = texture1;

            // シーンにレイヤーを追加し、そのレイヤーにオブジェクトを追加する。
            scene1.AddLayer(layer1);
            layer1.AddObject(object1);

            // 上と同じものをもう1セット作る。
            var scene2 = new asd.Scene();
            var layer2 = new asd.Layer2D();
            var object2 = new asd.TextureObject2D();

            var texture2 = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Scene2.png");
            object2.Texture = texture2;

            scene2.AddLayer(layer2);
            layer2.AddObject(object2);

            // シーンをシーン1に設定する。
            asd.Engine.ChangeScene(scene1);

            // Altseedのウインドウが閉じられていないか確認する。
            while(asd.Engine.DoEvents())
            {
                // Altseedを更新する。
                asd.Engine.Update();

                // マウスの左ボタンが押されるのを待つ。
                if(asd.Engine.Mouse.LeftButton.ButtonState == asd.MouseButtonState.Push)
                {
                    // フェードアウト・インによるシーン遷移を開始する。
                    // 1秒かけてフェードアウトし、1.5秒かけてフェードイン。
                    asd.Engine.ChangeSceneWithTransition(scene2, new asd.TransitionFade(1.0f, 1.5f));
                }
            }

            // Altseedを終了する。
            asd.Engine.Terminate();
        }
Exemple #38
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var obj = new asd.TextureObject2D();
            camera = new asd.CameraObject2D();

            obj.Texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Sample1.png");
            camera.Src = new asd.RectI(100, 100, 312, 312);
            camera.Dst = new asd.RectI(10, 10, 200, 200);

            layer.AddObject(obj);
            layer.AddObject(camera);
            scene.AddLayer(layer);
            asd.Engine.ChangeScene(scene);
        }
Exemple #39
0
        public void Run()
        {
            // aceを初期化する
            asd.Engine.Initialize("EffectObject2D", 640, 480, new asd.EngineOption());

            // シーンを生成する
            var scene = new asd.Scene();

            // レイヤーを生成する
            var layer = new asd.Layer2D();

            // シーンにレイヤーを追加する
            scene.AddLayer(layer);

            // シーンを切り替える
            asd.Engine.ChangeScene(scene);

            // エフェクトを読み込む
            var effect = asd.Engine.Graphics.CreateEffect("Data/Effect/magic.efk");

            // エフェクトオブジェクトを生成する
            var effectObj = new asd.EffectObject2D();

            // エフェクトをレイヤーに追加する
            layer.AddObject(effectObj);

            // エフェクトの位置、大きさを指定する
            effectObj.Position = new asd.Vector2DF(320, 240);
            effectObj.Scale = new asd.Vector2DF(50, 50);

            // エフェクトを設定する
            effectObj.Effect = effect;

            // エフェクトを再生する
            effectObj.Play();

            // aceが進行可能かチェックする。
            while (asd.Engine.DoEvents())
            {
                // aceを更新する。
                asd.Engine.Update();
            }

            // aceを終了する。
            asd.Engine.Terminate();
        }
Exemple #40
0
        protected override void OnUpdating()
        {
            if (Time % 9 == 0)
            {
            var texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Sample1.png");

            var obj = new asd.TextureObject2D();
            obj.Texture = texture;
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            layer.AddObject(obj);
            scene.AddLayer(layer);

            var transition = new asd.TransitionFade(3.0f / 60.0f, 3.0f / 60.0f);
            asd.Engine.ChangeSceneWithTransition(scene, transition);
            }
        }
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var obj = new asd.TextureObject2D();
            scene.AddLayer(layer);
            layer.AddObject(obj);
            asd.Engine.ChangeScene(scene);

            var g = asd.Engine.Graphics;
            var texture = g.CreateTexture2D("Data/Texture/Sample1.png");
            obj.Texture = texture;
            obj.Scale = new asd.Vector2DF(1, 1);

            var pe = new asd.PostEffectGrayScale();
            layer.AddPostEffect(pe);
        }
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var obj = new asd.TextObject2D();

            asd.Engine.ChangeScene(scene);
            scene.AddLayer(layer);
            layer.AddObject(obj);

            var font = asd.Engine.Graphics.CreateFont("Data/Font/Nac0812.aff");

            obj.Text = "DependencyPropertyは\n依存関係プロパティのこと";
            obj.Font = font;

            //object->SetCenterPosition(Vector2DF(128, 128));
            obj.Position = new asd.Vector2DF(0, 0);
        }
Exemple #43
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var effect = asd.Engine.Graphics.CreateEffect("Data/Effect/Laser01.efk");
            m_effectObj = new asd.EffectObject2D();

            layer.AddObject(m_effectObj);
            scene.AddLayer(layer);
            asd.Engine.ChangeScene(scene);

            m_effectObj.Position = new asd.Vector2DF(320, 240);
            m_effectObj.Scale = new asd.Vector2DF(20, 20);
            m_effectObj.EffectRotation = 90;

            m_effectObj.Effect = effect;
            m_effectObj.Play();
        }
Exemple #44
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var imagePackage = asd.Engine.Graphics.CreateImagePackage("Data/ImagePackage/test.aip");

            for (int  i = 0; i < imagePackage.ImageCount; i++)
            {
                var obj = new asd.TextureObject2D();

                obj.Texture = imagePackage.GetImage(i);
                obj.Position = new asd.Vector2DF(imagePackage.GetImageArea(i).X, imagePackage.GetImageArea(i).Y);
                layer.AddObject(obj);
            }

            scene.AddLayer(layer);
            asd.Engine.ChangeScene(scene);
        }
Exemple #45
0
        public void Run()
        {
            // aceを初期化する
            asd.Engine.Initialize("ImagePackage", 640, 480, new asd.EngineOption());

            // シーンを生成する
            var scene = new asd.Scene();

            // レイヤーを生成する
            var layer = new asd.Layer2D();

            // シーンにレイヤーを追加する
            scene.AddLayer(layer);

            // シーンを切り替える
            asd.Engine.ChangeScene(scene);

            // イメージパッケージを読み込む
            asd.ImagePackage imagePackage = asd.Engine.Graphics.CreateImagePackage("Data/ImagePackage/Game.aip");

            for(int i = 0; i < imagePackage.ImageCount; i++)
            {
                // テクスチャを取り出す
                asd.Texture2D texture = imagePackage.GetImage(i);
                asd.RectI area = imagePackage.GetImageArea(i);

                // テクスチャをオブジェクトとして追加する
                asd.TextureObject2D textureObject2D = new asd.TextureObject2D();
                textureObject2D.Texture = texture;
                textureObject2D.Position = new asd.Vector2DF(area.X, area.Y);
                layer.AddObject(textureObject2D);
            }

            // aceが進行可能かチェックする。
            while (asd.Engine.DoEvents())
            {
                // aceを更新する。
                asd.Engine.Update();
            }

            // aceを終了する。
            asd.Engine.Terminate();
        }
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var obj = new asd.TextureObject2D();
            scene.AddLayer(layer);
            layer.AddObject(obj);
            asd.Engine.ChangeScene(scene);

            var g = asd.Engine.Graphics;
            var texture = g.CreateTexture2D("Data/Texture/Sample1.png");
            obj.Texture = texture;
            obj.Scale = new asd.Vector2DF(1, 1);

            var pe = new asd.PostEffectLightBloom();
            pe.Intensity = 5.0f;
            pe.Threshold = 0.3f;
            pe.Exposure = 2.0f;
            layer.AddPostEffect(pe);
        }
        // シーンとレイヤーを手動で生成する。
        public void Run()
        {
            // Altseedを初期化する。
            asd.Engine.Initialize("SceneAndLayer_Basic", 640, 480, new asd.EngineOption());

            // 画像を読み込む。
            var texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Picture1.png");

            // シーンクラスのインスタンスを生成する。
            var scene = new asd.Scene();

            // レイヤークラスのインスタンスを生成する。
            var layer = new asd.Layer2D();

            //画像描画オブジェクトのインスタンスを生成する。
            var obj = new asd.TextureObject2D();

            // オブジェクトの位置とテクスチャを設定する。
            obj.Position = new asd.Vector2DF(50, 50);
            obj.Texture = texture;

            // 描画するシーンを指定する。
            asd.Engine.ChangeScene(scene);

            // 描画するレイヤーをシーンに追加する。
            scene.AddLayer(layer);

            // 描画するオブジェクトをレイヤーに追加する。
            layer.AddObject(obj);

            // Altseedのウインドウが閉じられていないか確認する。
            while (asd.Engine.DoEvents())
            {
                // Altseedを更新する。
                asd.Engine.Update();
            }

            // Altseedを終了する。
            asd.Engine.Terminate();
        }
Exemple #48
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Sample1.png");
            var textureObj1 = new asd.TextureObject2D();
            var textureObj2 = new asd.TextureObject2D();

            layer.AddObject(textureObj1);
            layer.AddObject(textureObj2);
            scene.AddLayer(layer);
            asd.Engine.ChangeScene(scene);

            textureObj1.Texture = texture;
            textureObj1.Src = new asd.RectF(256, 256, 256, 256);
            textureObj1.Position=new asd.Vector2DF(320, 240);

            textureObj2.Texture = texture;
            textureObj2.Src = new asd.RectF(0, 0, 256, 256);
            textureObj2.Position = new asd.Vector2DF(0, 0);
            textureObj2.TurnLR = true;
        }
Exemple #49
0
        public void Run()
        {
            // aceの初期化
            asd.Engine.Initialize("Object2DComponent", 640, 480, new asd.EngineOption());

            // 使用するシーン、レイヤー、オブジェクト、コンポーネントを生成
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var obj = new asd.TextureObject2D();
            var component = new RotateComponent();

            // シーンを変更
            asd.Engine.ChangeScene(scene);

            // シーンにレイヤーを追加
            scene.AddLayer(layer);

            // レイヤーにオブジェクトを追加
            layer.AddObject(obj);

            // オブジェクトに回転コンポーネントをコンポーネント名"Rotate"で追加
            obj.AddComponent(component, "Rotate");

            // テクスチャをロード
            var texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Block1.png");

            // オブジェクトに画像をセット
            obj.Texture = texture;

            // オブジェクトの位置を指定
            obj.Position = new asd.Vector2DF(320, 240);

            while(asd.Engine.DoEvents())
            {
                asd.Engine.Update();
            }

            asd.Engine.Terminate();
        }
        // レイヤーにグレースケールのポストエフェクトを適用する。
        public void Run()
        {
            // Altseedを初期化する
            asd.Engine.Initialize("PostEffect_GrayScale", 640, 480, new asd.EngineOption());

            // 画像を読み込む。
            var texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Picture1.png");

            // シーンクラスのインスタンスを生成する。
            var scene = new asd.Scene();

            // レイヤークラスのインスタンスを生成する。
            var layer = new asd.Layer2D();

            // 画像描画オブジェクトのインスタンスを生成する。
            var obj = new asd.TextureObject2D();

            // オブジェクトの位置とテクスチャを設定する。
            obj.Position = new asd.Vector2DF(50, 50);
            obj.Texture = texture;

            // シーンを変更し、そのシーンにレイヤーを追加し、そのレイヤーにオブジェクトを追加する。
            asd.Engine.ChangeScene(scene);
            scene.AddLayer(layer);
            layer.AddObject(obj);

            // レイヤーにグレースケールのポストエフェクトを適用する。
            layer.AddPostEffect(new asd.PostEffectGrayScale());

            // Altseedのウインドウが閉じられていないか確認する。
            while (asd.Engine.DoEvents())
            {
                // Altseedを更新する。
                asd.Engine.Update();
            }

            // Altseedを終了する。
            asd.Engine.Terminate();
        }
Exemple #51
0
        public void Run()
        {
            asd.Engine.Initialize("CustomPostEffect", 640, 480, new asd.EngineOption());

            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var obj = new asd.TextureObject2D()
            {
                Texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Sample1.png"),
            };

            layer.AddObject(obj);
            layer.AddPostEffect(new PostEffect(asd.Engine.Graphics));
            scene.AddLayer(layer);
            asd.Engine.ChangeScene(scene);

            while (asd.Engine.DoEvents())
            {
                asd.Engine.Update();
            }

            asd.Engine.Terminate();
        }
Exemple #52
0
        protected override void OnStart()
        {
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Sample1.png");
            var geometryObj1 = new asd.GeometryObject2D();
            var geometryObj2 = new asd.GeometryObject2D();
            var geometryObj3 = new asd.GeometryObject2D();
            var geometryObj4 = new asd.GeometryObject2D();
            var geometryObj5 = new asd.GeometryObject2D();
            var geometryObj6 = new asd.GeometryObject2D();

            layer.AddObject(geometryObj1);
            layer.AddObject(geometryObj2);
            layer.AddObject(geometryObj3);
            layer.AddObject(geometryObj4);
            layer.AddObject(geometryObj5);
            layer.AddObject(geometryObj6);

            scene.AddLayer(layer);
            asd.Engine.ChangeScene(scene);

            {
                var circle = new asd.CircleShape();
                circle.OuterDiameter = 100.0f;
                circle.InnerDiameter = 10.0f;
                circle.NumberOfCorners = 96;
                circle.Position = new asd.Vector2DF(100, 50);

                geometryObj1.Shape = circle;
                geometryObj1.Texture = texture;
                geometryObj1.Position = new asd.Vector2DF(0, 0);
            }

            {
                var arc = new asd.ArcShape();
                arc.OuterDiameter = 100;
                arc.InnerDiameter = 10;
                arc.NumberOfCorners = 96;
                arc.Position = new asd.Vector2DF(300, 50);
                arc.StartingCorner = 90;
                arc.EndingCorner = 5;

                geometryObj2.Shape = arc;
                geometryObj2.Texture = texture;
                geometryObj2.Position = new asd.Vector2DF(0, 0);
            }

            {
                var line = new asd.LineShape();
                line.StartingPosition = new asd.Vector2DF(410, 50);
                line.EndingPosition = new asd.Vector2DF(630, 50);
                line.Thickness = 5.0f;

                geometryObj3.Shape = line;
                geometryObj3.Position = new asd.Vector2DF(0, 0);
            }

            {
                var rect = new asd.RectangleShape();
                rect.DrawingArea = new asd.RectF(10, 110, 300, 200);
                rect.UV = new asd.RectF(0.0f, 0.0f, 0.5f, 0.5f);

                geometryObj4.Shape = rect;
                geometryObj4.Texture = texture;
                geometryObj4.Position = new asd.Vector2DF(0, 0);
            }

            {
                var triangle = new asd.TriangleShape();
                triangle.SetPointByIndex(new asd.Vector2DF(320, 350), 0);
                triangle.SetPointByIndex(new asd.Vector2DF(100, 450), 1);
                triangle.SetPointByIndex(new asd.Vector2DF(540, 450), 2);

                triangle.SetUVByIndex(new asd.Vector2DF(0.5f, 0.2f), 0);
                triangle.SetUVByIndex(new asd.Vector2DF(0.1f, 0.5f), 1);
                triangle.SetUVByIndex(new asd.Vector2DF(0.9f, 0.7f), 2);

                geometryObj5.Shape = triangle;
                geometryObj5.Texture = texture;
                geometryObj5.Position = new asd.Vector2DF(0, 0);
            }

            {
                var polygon = new asd.PolygonShape();

                for (int i = 0; i < 10; ++i)
                {
                    asd.Vector2DF vec = new asd.Vector2DF(1, 0);
                    vec.Degree = i * 36;
                    vec.Length = (i % 2 == 0) ? 100 : 55;
                    polygon.AddVertex(vec + new asd.Vector2DF(500, 250));

                }

                geometryObj6.Shape = polygon;
                geometryObj6.Texture = texture;
                geometryObj6.Position = new asd.Vector2DF(0, 0);
            }
        }
Exemple #53
0
        public void Run()
        {
            // 説明
            Console.WriteLine("Z : グレースケール追加");
            Console.WriteLine("X : セピア調追加");
            Console.WriteLine("C : ガウスぼかし追加");
            Console.WriteLine("V : ライトブルーム追加");
            Console.WriteLine("A : 全てのポストエフェクト消去");

            // aceを初期化する
            asd.Engine.Initialize("PostEffect", 640, 480, new asd.EngineOption());

            // シーン等を初期化する
            var scene = new asd.Scene();
            var layer = new asd.Layer2D();
            var effectObj = new asd.EffectObject2D();
            var effect = asd.Engine.Graphics.CreateEffect("Data/Effect/magic.efk");

            scene.HDRMode = true; ;
            scene.AddLayer(layer);
            layer.AddObject(effectObj);
            asd.Engine.ChangeScene(scene);

            effectObj.Scale = new asd.Vector2DF(50, 50);
            effectObj.Position = new asd.Vector2DF(320, 240);
            effectObj.Effect = effect;
            effectObj.Play();

            // aceが進行可能かチェックする。
            while (asd.Engine.DoEvents())
            {
                // aceを更新する。
                asd.Engine.Update();

                // Aを押したらポストエフェクトを全て破棄する。
                if (asd.Engine.Keyboard.GetKeyState(asd.Keys.A) == asd.KeyState.Push)
                {
                    layer.ClearPostEffects();
                }

                // Zを押したらグレースケールを追加する。
                if (asd.Engine.Keyboard.GetKeyState(asd.Keys.Z) == asd.KeyState.Push)
                {
                    var posteffect = new asd.PostEffectGrayScale();
                    layer.AddPostEffect(posteffect);
                }

                // Xを押したらセピアを追加する。
                if (asd.Engine.Keyboard.GetKeyState(asd.Keys.X) == asd.KeyState.Push)
                {
                    var posteffect = new asd.PostEffectSepia();
                    layer.AddPostEffect(posteffect);
                }

                // Cを押したらガウスぼかしを追加する。
                if (asd.Engine.Keyboard.GetKeyState(asd.Keys.C) == asd.KeyState.Push)
                {
                    var posteffect = new asd.PostEffectGaussianBlur();
                    posteffect.Intensity = 5.0f;
                    layer.AddPostEffect(posteffect);
                }

                // Vを押したらライトブルームを追加する。
                if (asd.Engine.Keyboard.GetKeyState(asd.Keys.V) == asd.KeyState.Push)
                {
                    var posteffect = new asd.PostEffectLightBloom();
                    posteffect.Intensity = 10.0f;
                    posteffect.Exposure = 1.0f;
                    posteffect.Threshold = 0.3f;
                    layer.AddPostEffect(posteffect);
                }
            }

            // aceを終了する。
            asd.Engine.Terminate();
        }
Exemple #54
0
        public Scene2()
        {
            //レイヤーを追加する。
            var layer = new asd.Layer2D();
            AddLayer(layer);

            //Block1.pngを描画するテクスチャオブジェクトを設定する。
            obj = new asd.TextureObject2D();
            obj.Texture = asd.Engine.Graphics.CreateTexture2D("Data/Texture/Block1.png");
            obj.Position = new asd.Vector2DF(100, 100);
            layer.AddObject(obj);
        }