Exemplo n.º 1
0
        private void mapScreen_MouseClick(object sender, MouseEventArgs ea)
        {
            var ee = ea.Location;

            if (ee.X < 0)
            {
                ee.X += 32768 * 2;
            }
            if (ee.Y < 0)
            {
                ee.Y += 32768 * 2;
            }
            int WIDTH = ConfigScript.getScreenWidth(curActiveLevelForScreen);
            int HEIGHT = ConfigScript.getScreenHeight(curActiveLevelForScreen);
            int dx, dy;

            if (ConfigScript.getScreenVertical())
            {
                dy = ee.X / (int)(layers[0].blockWidth * curScale);
                dx = ee.Y / (int)(layers[0].blockHeight * curScale) - 1;
            }
            else
            {
                dx = ee.X / (int)(layers[0].blockWidth * curScale) - 1;
                dy = ee.Y / (int)(layers[0].blockHeight * curScale);
            }

            if (ea.Button == MouseButtons.Right)
            {
                if (dx == WIDTH || dx == -1)
                {
                    return;
                }
                int index = dy * WIDTH + dx;
                curActiveBlock = ConfigScript.getBigTileNoFromScreen(layers[0].screens[curActiveScreen], index);
                if (curActiveBlock != -1)
                {
                    activeBlock.Image  = bigBlocks[curActiveBlock];
                    lbActiveBlock.Text = String.Format("Label: {0:X}", curActiveBlock);
                }
                blocksScreen.Invalidate();
                return;
            }
        }
Exemplo n.º 2
0
        private static void renderLayer(Graphics g, BlockLayer layer, RenderParams renderParams)
        {
            bool needRenderLayer = layer != null && layer.showLayer;

            if (!needRenderLayer)
            {
                return;
            }

            int tileSizeX = renderParams.getTileSizeX();
            int tileSizeY = renderParams.getTileSizeY();

            int size = renderParams.getLayerSize();

            for (int i = 0; i < size; i++)
            {
                int       bigBlockNo = ConfigScript.getBigTileNoFromScreen(layer.data, i);
                Rectangle tileRect   = new Rectangle((i % renderParams.width) * tileSizeX + renderParams.leftMargin, i / renderParams.width * tileSizeY + renderParams.topMargin, tileSizeX, tileSizeY);
                renderParams.renderBlock(g, bigBlockNo, tileRect);
            }
        }
Exemplo n.º 3
0
        private void renderNeighbornLine(Graphics g, int screenNo, int line, int X)
        {
            int WIDTH       = ConfigScript.getScreenWidth(curActiveLevelForScreen);
            int HEIGHT      = ConfigScript.getScreenHeight(curActiveLevelForScreen);
            int TILE_SIZE_X = (int)(layers[0].blockWidth * curScale);
            int TILE_SIZE_Y = (int)(layers[0].blockHeight * curScale);
            int SIZE        = WIDTH * HEIGHT;

            int[] indexesPrev = layers[0].screens[screenNo];
            for (int i = 0; i < SIZE; i++)
            {
                if (i % WIDTH == line)
                {
                    int bigBlockNo = ConfigScript.getBigTileNoFromScreen(indexesPrev, i);
                    if (bigBlockNo < bigBlocks.Length)
                    {
                        g.DrawImage(bigBlocks[bigBlockNo], new Rectangle(X, i / WIDTH * TILE_SIZE_Y, TILE_SIZE_X, TILE_SIZE_Y));
                    }
                }
            }
        }
Exemplo n.º 4
0
        private void renderNeighbornLine(Graphics g, int scrNo, int line, int x)
        {
            Screen prevScreen = screens[scrNo];
            int    width      = prevScreen.width;
            int    height     = prevScreen.height;
            int    tileSizeX  = (int)(bigBlocks[0].Width * curScale);
            int    tileSizeY  = (int)(bigBlocks[0].Height * curScale);
            int    size       = width * height;

            int[] indexesPrev = prevScreen.layers[0].data;
            for (int i = 0; i < size; i++)
            {
                if (i % width == line)
                {
                    int bigBlockNo = ConfigScript.getBigTileNoFromScreen(indexesPrev, i);
                    if ((bigBlockNo >= 0) && (bigBlockNo < bigBlocks.Length))
                    {
                        g.DrawImage(bigBlocks[bigBlockNo], new Rectangle(x, i / width * tileSizeY, tileSizeX, tileSizeY));
                    }
                }
            }
        }
Exemplo n.º 5
0
        private void mapScreen_MouseClick(object sender, MouseEventArgs ea)
        {
            var ee = ea.Location;

            if (ee.X < 0)
            {
                ee.X += 32768 * 2;
            }
            if (ee.Y < 0)
            {
                ee.Y += 32768 * 2;
            }

            var screen = getActiveScreen();

            int width = screen.width;

            int dx = ee.X / (int)(bigBlocks[0].Width * curScale) - 1;
            int dy = ee.Y / (int)(bigBlocks[0].Height * curScale);

            if (ea.Button == MouseButtons.Right)
            {
                if (dx == width || dx == -1)
                {
                    return;
                }
                int index = dy * width + dx;
                var layer = getActiveLayer(screens[screenNo]);
                curActiveBlock = ConfigScript.getBigTileNoFromScreen(layer.data, index);
                if (curActiveBlock != -1)
                {
                    activeBlock.Image  = bigBlocks[curActiveBlock];
                    lbActiveBlock.Text = String.Format("Label: {0:X}", curActiveBlock);
                }
                blocksScreen.Invalidate();
            }
        }
Exemplo n.º 6
0
        public static void Render(Graphics g, Image[] bigBlocks, Rectangle?visibleRect, BlockLayer[] layers, int scrNo, float CurScale, bool ShowBorder, bool showBlocksAxis, int LeftMargin, int TopMargin, int WIDTH, int HEIGHT)
        {
            g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
            g.PixelOffsetMode   = System.Drawing.Drawing2D.PixelOffsetMode.Half;

            bool verticalScreen = ConfigScript.getScreenVertical();
            int  SIZE           = WIDTH * HEIGHT;

            for (int layerIndex = 0; layerIndex < layers.Length; layerIndex++)
            {
                var  layer           = layers[layerIndex];
                bool needRenderLayer = layer != null && layer.screens != null && layer.screens[scrNo] != null && layer.showLayer;
                if (!needRenderLayer)
                {
                    continue;
                }

                int TILE_SIZE_X = (int)(layer.blockWidth * CurScale);
                int TILE_SIZE_Y = (int)(layer.blockHeight * CurScale);

                for (int i = 0; i < SIZE; i++)
                {
                    int       bigBlockNo = ConfigScript.getBigTileNoFromScreen(layer.screens[scrNo], i);
                    Rectangle tileRect;
                    if (verticalScreen)
                    {
                        tileRect = new Rectangle(i / WIDTH * TILE_SIZE_X + TopMargin, (i % WIDTH) * TILE_SIZE_Y + LeftMargin, TILE_SIZE_X, TILE_SIZE_Y);
                    }
                    else
                    {
                        tileRect = new Rectangle((i % WIDTH) * TILE_SIZE_X + LeftMargin, i / WIDTH * TILE_SIZE_Y + TopMargin, TILE_SIZE_X, TILE_SIZE_Y);
                    }

                    if (visibleRect == null || visibleRect.Value.Contains(tileRect) || visibleRect.Value.IntersectsWith(tileRect))
                    {
                        if (bigBlockNo > -1 && bigBlockNo < bigBlocks.Length)
                        {
                            g.DrawImage(bigBlocks[bigBlockNo], tileRect);
                            if (showBlocksAxis)
                            {
                                g.DrawRectangle(new Pen(Color.FromArgb(255, 255, 255, 255)), tileRect);
                            }
                        }
                        //else
                        //    g.FillRectangle(Brushes.White, tileRect);
                    }
                }
            }

            if (ShowBorder)
            {
                int TILE_SIZE_X = (int)(layers[0].blockWidth * CurScale);
                int TILE_SIZE_Y = (int)(layers[0].blockHeight * CurScale);
                if (verticalScreen)
                {
                    g.DrawRectangle(new Pen(Color.Green, 4.0f), new Rectangle(0, TILE_SIZE_Y, TILE_SIZE_X * HEIGHT, TILE_SIZE_Y * WIDTH));
                }
                else
                {
                    g.DrawRectangle(new Pen(Color.Green, 4.0f), new Rectangle(TILE_SIZE_X, 0, TILE_SIZE_X * WIDTH, TILE_SIZE_Y * HEIGHT));
                }
            }

            //Additional rendering  //float to int!
            ConfigScript.renderToMainScreen(g, (int)CurScale);
        }
Exemplo n.º 7
0
        private void mapScreen_MouseMove(object sender, MouseEventArgs ea)
        {
            var ee = ea.Location;

            if (ee.X < 0)
            {
                ee.X += 32768 * 2;
            }
            if (ee.Y < 0)
            {
                ee.Y += 32768 * 2;
            }

            if (selectionRect)
            {
                selectionMouseX = ee.X;
                selectionMouseY = ee.Y;
                mapScreen.Invalidate();
                return;
            }
            var screen = getActiveScreen();
            int width  = screen.width;
            int dx     = ee.X / (int)(bigBlocks[0].Width * curScale) - 1;
            int dy     = ee.Y / (int)(bigBlocks[0].Height * curScale);

            lbCoords.Text = String.Format("Coords:({0},{1})", dx, dy);

            bool curDeltaChanged = curDx != dx || curDy != dy;

            if (curDeltaChanged)
            {
                curDx = dx;
                curDy = dy;
            }
            if (curClicked)
            {
                if (dx == width)
                {
                    if (screenNo < ConfigScript.screensOffset[0].recCount - 1)
                    {
                        int index = dy * width;
                        var layer = getActiveLayer(screens[screenNo + 1]);
                        curActiveBlock = ConfigScript.getBigTileNoFromScreen(layer.data, index);
                        ConfigScript.setBigTileToScreen(layer.data, index, curActiveBlock);
                        dirty = true; updateSaveVisibility();
                    }
                }
                else if (dx == -1)
                {
                    if (screenNo > 0)
                    {
                        int index = dy * width + (width - 1);

                        var layer = getActiveLayer(screens[screenNo - 1]);
                        ConfigScript.setBigTileToScreen(layer.data, index, curActiveBlock);
                        dirty = true; updateSaveVisibility();
                    }
                }
                else
                {
                    if (!useStructs)
                    {
                        int index = dy * width + dx;
                        var layer = getActiveLayer(screens[screenNo]);
                        if (index < layer.data.Length)
                        {
                            ConfigScript.setBigTileToScreen(layer.data, index, curActiveBlock);
                        }
                        dirty = true; updateSaveVisibility();
                    }
                    else
                    {
                        if (!isPhysicsLayerSelected()) //disable structs for physics layer
                        {
                            appendCurTileStruct(dx, dy);
                            dirty = true;
                            updateSaveVisibility();
                        }
                    }
                }
            }
            mapScreen.Invalidate();
        }