Wednesday, September 26, 2018

Processing Image [animated]





//So some advice I got when learning Unity this summer was to simply name variables something that evokes their
//purpose but I apologize in advance if my freudian brain definitions make no sense in english.


//Rectangles
//amount of rectangles to be drawn
int rectCount = 100;
//arrays for setting the position of the rectangles
float[] rectPosX;
float[] rectPosY;
//rate that the rectangles will tremble
float rectWander = .2;

//colours for the background
int[] bColour = new int[3];
//colour range
int negativeLimit = 240;
int positiveLimit = 255;

//Arc shape
//arc rotation
float arcMotion;

//Vein graphics
//ammount of veins to be drawn
int veinCount = 30;
//arrays for the positions of the circle trails
float[] veinPosX;
float[] veinPosY;

void setup()
{
  size(1000, 800);
  background(200);
 
  //initiates the starting positions of the squares and circle trails
  squareSetup();
  veinSetup();
}

void draw()
{
  //draw the background
  drawBackground();
 
  //draw veins
  drawVeins();

  //draw Rectangles
  drawSquares();

  //draw center arc
  polarShape();
}


//Setup functions

//set the positions of all the squares inside the array
void squareSetup()
{
  //set the size of the arrays for the rectangle positions
  rectPosX = new float[rectCount];
  rectPosY = new float[rectCount];

  //set each value in the array to a random position
  for (int a = 0; a< rectCount; a++)
  {
    rectPosX[a] = random(0, width);
    rectPosY[a] = random(0, height);
  }
}

void veinSetup()
{
  //set the position arrays to set amount
  veinPosX = new float[veinCount];
  veinPosY = new float[veinCount];
 
  //set random X positions
  for (int a = 0; a < veinCount; a++)
  {
    //set x positions randomly along screen width
    veinPosX[a] = random(0, width);
    //set y positions randomly below screen with some offset
    veinPosY[a] = random(height, height + height/2);
  }
}

//DrawFunctions

//change the background colour
void drawBackground()
{
  //change the value for each colour
  for (int a = 0; a < bColour.length; a ++)
  {
    //make the colour values change at random
    bColour[a] += int(random(-3, 3));

    //add or subtract the colour values if they fall out of
    //set range
    if (bColour[a] < negativeLimit)
    {
      bColour[a] = negativeLimit;
    }
    if (bColour[a] > positiveLimit)
    {
      bColour[a] = positiveLimit;
    }
  }

  //manually limit a colour's range outside of automated loop
  bColour[1] -= 10;
 
  //draw the background
  fill(bColour[0], bColour[1], bColour[2], 7);
  rect(0, 0, width, height);

}


//draw the squares
void drawSquares()
{
  noStroke();
  fill(150, 150, 150);
  //draw all of the rectangles with their set locations
  for (int a = 0; a < rectCount; a ++)
  {
    //draw rectangles
    rect(rectPosX[a], rectPosY[a], 50, 80);
    //make the rectangles tremble
    rectPosX[a] += random(-rectWander, rectWander);
    rectPosY[a] += random(-rectWander, rectWander);
  }
}


void polarShape()
{
  //rotating arc shape
  fill(255, 220, 175);
  arc(width/2, height/2, 300, 300, radians(arcMotion*2), radians(arcMotion*2 + 90));
 
  //bottom pulse circle
  fill(180, 120, 300);
  ellipse(width/2, height/2, 250 * cos(arcMotion*.01), 250* cos(arcMotion*.01));
 
  //top pulse circle
  fill(100, 100, 300);
  ellipse(width/2, height/2, 250 * sin(arcMotion*.01), 250*sin(arcMotion*.01));
 
  //rotate the arc shape
  arcMotion +=2;
}

//draw trailing circles that move upwards
void drawVeins()
{
  //Im not sure why im commenting these functions still it's pretty hard to forget them at this point
  fill(200, 100, 150);
  //draw all the circles
  for (int a = 0; a < veinCount; a ++)
  {
    //draw the circles
    ellipse(veinPosX[a], veinPosY[a], 10, 10);
    //make the circle trail wander
    veinPosX[a] += random(-3, 3);


    //make the circles move upwards towards the origin;
    veinPosY[a] -=3;
   
    //if the trails rise above the screen reset them randomly
    if(veinPosY[a] < 0)
    {
      veinPosY[a] = random(height, height + height/2);
    }
  }
}

Thursday, September 20, 2018

Hello World

My name is Jonathan Da Roza, after being introduced to Object Oriented Programming I've been busy learning Unity engine working on some basic game prototypes while also keeping in touch with a some acquaintances in the industry. I've previously been interested in the Drawing program at ACAD however I am finding that the element of interaction and play and sharing that with people is much more rewarding to me as an Artist. I take inspiration from many things, games, books, anime, television, movies. I can't say I take inspiration from a specific genre because I look for where this medium succeeds and where it fails based on what the story set itself up to achieve, I think mingling genres and mediums is where people get inventive and start rejuvenating the medium with new methods. Personally I find that parts theory in psychology is how my brain perceives and manages my emotions and thoughts and I find the narratives it constructs seemingly automatically is a great inspiration for the narrative and tonal directions I want to take my art, it also doubles as a way for me to meditate and express pent up emotions or ideas by sharing it with the world more accurate that if I stated them vocally.

What I'm looking for in computational art is to further my understanding of object programming as currently it is still at the level of basic class and variable manipulation, I think at my level I want to start learning some higher level systems in the language programs and I think that will allow me to build larger more nuanced systems.



One of the prototypes I started at the beginning of 2018 in January, my concept was a game built around modular objects, items, body parts, vehicles could be assembled and destroyed as well as each part had attributes. This quickly became an over ambitious project especially including I was at a beginners level. I dropped this project in the spring but I think the experience I gained by taking on an over-sized project definitely has helped build my understanding of Unity and C# as well as problem solving and refactoring code.


Basic walking animation


My next project came inspired by the old early polygonal consoles and the mascot platforms that came out of them like Mario 64 and Banjo Kazooie, I took to these older games figuring that the current technology would allow me to make them at a lower skill level with Unity's built in Physics library. I managed basic movement input and output as well as started building systems. My idea was a game built around free climbing buildings and structures. The first system would stick the player onto the wall and allow you to move in any direction on it. The second would look for vertical surfaces like window sills or beams to cling to and move horizontally along them. The third system would search for new ledges to grab onto so one could scale them up and down like a ladder. I did also attempt to make a system to activate other object like a basic bicycle that the player could ride. This project was forming into a working prototype however I dropped it late July as I realized making gameplay beyond this is still beyond my skill level and my lack of experience in game design would slow down my workflow to a crawl.

A platformer build with climbing mechanics


My current project would fall into the Metroidvania genre, a 2D dungeon crawler with a mixture of platforming and combat. After having to drop the last 2 projects I figured this would be the ideal template since 2D platformers are generally considered entry level projects and I could add features in modules so if they ever get to overambitious I can simply drop it from the game. The current build I have is press sensitive jumping, basic movement and dashing, projectile spawning, health systems and pass through platforms. I'm currently working on the infrastructure for an equipment system that enables more mechanics in modules, this way I can add mechanics to the game like double jumping or new attacks without worrying about being too experimental or ambitious as well it adds a unique design of players gathering items and constructing their own play style.

My current "Metroidvania" type game

Currently I'm working on refactoring some code to make it more efficient and more readable, it's easy to add a feature and leave it at that but at it's current stage it's too unstable to continue development so I'll need a few days to smooth the systems out.