April DevLog

Hello everyone!!!

What is DaFridge'sAdventures2?

Is my desire to develop an Indie game, completely designed by me.

Here in this devLog I will tell you a little about the design choices I have made so far.

This month I will start with the graphics.

I don't use a game engine, I program directly in C# using Monogame. I chose the hard way because I like to learn and because it gives me more freedom to customize the game, the only disadvantage is that it takes a lot of time and patience.

Having said that I like pixelart, in order to learn the basics I took a couple of courses on an online platform called Udemy. And several tutorials on YouTube.

There I realized one thing: before you even start programming you need a concept-art that gives a little bit of the final look that the game will have, and to do that you first need a Color Palette.

Online there are sites where various artists provide palettes for creating pixelart designs, such as Lospec.

After several trials I decided to create my own palette, and put a base limit of 16 colors for my game.

The result is this:

Which you can also find here:

https://lospec.com/palette-list/2d-comic-exploration-game-dafridgesadventures2

To do some testing and to get an idea of the final palette I wanted to use I wrote a script in Python that made things easier for me.

It is as follows:

#!/usr/bin/python
# -*- coding: utf-8 -*-
""" 
           The Artistic License 2.0
    Copyright (c) 2000-2006, The Perl Foundation.
 Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 ----------------------------------------
 Author: danielkun
 ----------------------------------------
"""
import colorsys
import random
from PIL import Image
class Paletter:
    def __init__(self):
        # basic saturation is 50, value is 75. We want 20 colors of choise
        self.n_colors = 20
        self.basic_sat = 50
        self.basic_val = 75
        self.colors = []
    def run(self):
        angle = 360 / self.n_colors
        # pick some hues based on the number of colors selected.
        hues = [c * angle for c in range(self.n_colors)]
        
        self.colors = []
        for hue in hues:
            sat = self.basic_sat + random.randint(-3, 3) * 10 # adjust random saturation
            val = self.basic_val + random.randint(-3, 3) * 10 # adjust random value
            for i in range(random.randint(2, 3)): # pick 2 or 3 colors near the same hue.
                r, g, b = colorsys.hsv_to_rgb(hue / 360, val / 100, sat / 100) # obtain rgb from hue value and saturation.
                r = int(r * 255)
                g = int(g * 255)
                b = int(b * 255)
                self.colors.append((r, g, b))
                sat += random.randint(1, 5) * 4 # adjust random saturation for new color... increasing the saturation
                val -= random.randint(1, 5) * 3 # adjust random value for new color...      decreasing the value
    def draw(self):
        """Draw method using PIL"""
        
        img = Image.new("RGB", (32 * 16, 32), (255, 255, 255))
        while len(self.colors) > 16:
            self.colors.pop(random.randint(0, len(self.colors) - 1)) # pop out random colors from the basic collection untill we have 16 colors left.
        for k, color in enumerate(self.colors):
            for j in range(32):
                for i in range(32):
                    img.putpixel((i + k * 32, j), color)
        img.save("./game_palette.png", "png")
if __name__ == '__main__':
    p = Paletter()
    p.run()
    p.draw()

Obviously the game has more than 16 colors, there are light and transparency effects, and the background objects I drew by increasing the saturation of the base Tilesets.

I like the result and so I will continue to use this palette for this game in the future.

I am always open to opinions and feedback from my players, so far I have learned a lot about the importance of color choice and if I went back I would have tried something more stringent with fewer colors but I will leave that for other projects.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

DevLog Aprile

Ciao a tutti!

Che cos'è DaFridge'sAdventures2?

è il mio desiderio di sviluppare un gioco Indie, completamente ideato da me.

Ecco che in questo devLog vi parlerò un po' delle scelte progettuali che ho fatto finora.

In questo mese inizierò dalla grafica.

Io non uso un motore di gioco, programmo direttamente in C# usando Monogame. Ho scelto la strada difficile perché mi piace imparare e perché mi dà più libertà di customizzare il gioco, l'unico svantaggio è che ci vuole tanto tempo e pazienza.

detto questo mi piace la pixelart, per poter imparare le basi ho seguito un paio di corsi su una piattaforma online chiamata Udemy. E diversi tutorial su YouTube.

Li ho capito una cosa: prima ancora di iniziare a programmare ci vuole un concept-art che dia un po' l'aspetto finale che avrà il gioco e per farlo ci vuole inanzitutto una Palette di colori.

Online ci sono siti dove vari artisti mettono a disposizione palette per creare disegni in pixelart, come per esempio Lospec.

Dopo diverse prove ho deciso di crearmi da solo la palette, e di mettere un limite base di 16 colori per il mio gioco.

Il risultato è questo:

che potete trovare anche qui:

https://lospec.com/palette-list/2d-comic-exploration-game-dafridgesadventures2

per fare qualche test e per farmi un'idea della palette finale che volevo usare ho scritto uno script in Python che mi facilitava le cose.

è il seguente:

#!/usr/bin/python
# -*- coding: utf-8 -*-
""" 
           The Artistic License 2.0
    Copyright (c) 2000-2006, The Perl Foundation.
 Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 ----------------------------------------
 Author: danielkun
 ----------------------------------------
"""
import colorsys
import random
from PIL import Image
class Paletter:
    def __init__(self):
        # basic saturation is 50, value is 75. We want 20 colors of choise
        self.n_colors = 20
        self.basic_sat = 50
        self.basic_val = 75
        self.colors = []
    def run(self):
        angle = 360 / self.n_colors
        # pick some hues based on the number of colors selected.
        hues = [c * angle for c in range(self.n_colors)]
        
        self.colors = []
        for hue in hues:
            sat = self.basic_sat + random.randint(-3, 3) * 10 # adjust random saturation
            val = self.basic_val + random.randint(-3, 3) * 10 # adjust random value
            
            for i in range(random.randint(2, 3)): # pick 2 or 3 colors near the same hue.
                r, g, b = colorsys.hsv_to_rgb(hue / 360, val / 100, sat / 100) # obtain rgb from hue value and saturation.
                r = int(r * 255)
                g = int(g * 255)
                b = int(b * 255)
                self.colors.append((r, g, b))
                sat += random.randint(1, 5) * 4 # adjust random saturation for new color... increasing the saturation
                val -= random.randint(1, 5) * 3 # adjust random value for new color...      decreasing the value
    def draw(self):
        """Draw method using PIL"""
        
        img = Image.new("RGB", (32 * 16, 32), (255, 255, 255))
        while len(self.colors) > 16:
            self.colors.pop(random.randint(0, len(self.colors) - 1)) # pop out random colors from the basic collection untill we have 16 colors left.
        for k, color in enumerate(self.colors):
            for j in range(32):
                for i in range(32):
                    img.putpixel((i + k * 32, j), color)
        img.save("./game_palette.png", "png")
if __name__ == '__main__':
    p = Paletter()
    p.run()
    p.draw()

Ovviamente il gioco ha più di 16 colori, ci sono effetti luminosi e di trasparenza, e gli oggetti di sfondo li ho disegnati incrementando la saturazione dei Tileset di base.

Il risultato mi piace e quindi in futuro continuerò a utilizzare questa palette per questo gioco.

Sono sempre aperto a opinioni e feedback dai miei giocatori, finora ho imparato molto sull'importanza della scelta dei colori e se tornassi indietro avrei tentato qualcosa di più stringente con meno colori ma questo lo lascerò per altri progetti.