pxl | A simple framework for making games in Rust | Game Engine library

What you want:

if you want all the elements, will be in a row,
so not like display: inline but one under other.

what to do:

just add display: grid in your parent element, in this case

this automatically does for you, and is also responsive!

more details:

• https://developer.mozilla.org/en-US/docs/Learn/CSS/CSS_layout/Grids

complete fixed code:

An issue I see is that in the ngOnInit, you're subscribing to the store but you're not unsubscribing ever. This will lead to a leak where at one point in time this component is not even on the screen (it is destroyed) but that subscription will still be running.

Do this to fix it:

Maybe a different approach will work. I'm not using an actual image for this to as to not deal with security issues but the process should still work.

First thing I like to do when dealing with img.data is I like to create an array that gives each pixel it's own array; a 2d array. i.e [[0, 0, 0, 0,], [255, 0, 255, 0]...]. For me personally it makes it easier to deal with.

To iterate one of my comments from this thread:

When running my assembly code with the mov [bx], ax instruction for painting pixels, every time this instruction is to be executed, my machine is using the CPU - already burdened with other tasks - to access and write to the screen memory (VRAM at A000H or B000H) all by itself, which takes up too much time. (See Refresh Rates, V-Sync Settings and Frame Buffers Explained on YouTube and 'Framebuffer' on Wiki.)

[EDIT:] While you can access two bytes / one word at a time with rep stosw, that is still not enough to paint a whole image screen-size in a flash.

In order to fulfill the goal of creating a 2D game-like demo (with or without scrolling ability), you would have to learn to capture a 320x200 part of a very large image. But to do that you have to learn to capture at least any 320x200 image. And to do that you would have to tap into the hardware directly or indirectly to store an image in a chunk of its memory. To do something like accessing the hardware indirectly you would need to write your own video driver. It was pointed out by a number of people that reinventing the wheel by way of doing all of this in Assembly is a tedious practice (as argued here). You are better off doing all of this in C unless there is a particular specialized task that cannot be accomplished in C.

There may not be a need for a DMA to relieve the CPU of the accessing/writing operations. And in the '80s there were no graphics accelerators with graphics libraries and GPUs, which came in only in the early 90's to make animation much more fluid in worlds of higher definition. (See 'DMA' on Wiki.)

• If you want to create a bitmap image of 8bit per color (24bit per pixel), assign BMPINFOHEADERFILE.bitCount to 24, not 4.
• Your struct BMPHEADER may be padded and word-aligned after char BM[2], which causes misalignment of the bitmap file format. To avoid this, say struct __attribute__ ((__packed__)) BMPHEADER {..}.
• The value of BMPHEADERFILE.Size should be 54+270000, not 52+270000.
• As for the random pixel values, rand() % 17 generates the pixel values between 0 and 17, which will be too dark to see. rand() % 256 might be better in terms of visibility.

You move to center in wrong way.

In first you substract c_x from px and py.
In second you substract c_y from px and py.

You need to get an integer, not a string:

You don't need a JS script in order for retargeting to work. Many vendors will provide a simple image pixel. You'll basically send a ping to the vendor each time a page is loaded.

JS would allow you to do more advanced things like read cookies and global variables to collect more information. But maybe you could reach out to who sent you the script and see if a JS script is provided. If not, you should be good to go with just the image pixel.

First: at the end of your function, you have: