# WCCChallenge_MesoAmerican

# TalesIn20

For this week's Creative Code Challenge by @sableraph: "MesoAmerican”, **Talesin20** is coded in ***P5JS, Hydra, SonicPi***. It Translates the current usage of the decimal systems and translates it into the base20 system that was used by the Aztecs: [https://mathworld.wolfram.com/Vigesimal.html](https://mathworld.wolfram.com/Vigesimal.html). While the sound is reflective of the speculative thoughts surronding the Aztec and Mayan Calendars/Crop Circles.

## Poem

```ocaml
The base may not be the same
But the propose is still a similar aim
To represent the information around
Pass down
That becomes endowed
Within ourselves
Rhythms within our reflects
Re step in the steps
That merge back to thoughts that deflect
As we merge the patterns hidden
In the rhythm
What was once submerged
Becomes visible once merged
```

## Video Version

<iframe width="560" height="315" src="https://www.youtube.com/embed/FKxIHN_SNls?si=Y8v_mySjaPnTgq5w"></iframe>

## Interactive P5: TalesIn20

[https://editor.p5js.org/illestknock/full/x3hXK5PEP](https://editor.p5js.org/illestknock/full/x3hXK5PEP)

## Images

![](https://scontent-lga3-2.xx.fbcdn.net/v/t39.30808-6/434202979_1305892076998035_5565179312096775301_n.jpg?_nc_cat=109&ccb=1-7&_nc_sid=5f2048&_nc_ohc=LZuadw9iR4sAX86i_f-&_nc_ht=scontent-lga3-2.xx&oh=00_AfBlVSblPb0Eec2dhjNKHUydahPSAAdLQxixHOxPtoRb3w&oe=660916E6 align="center")

![](https://scontent-lga3-2.xx.fbcdn.net/v/t39.30808-6/434177763_1305892080331368_8999334141084219699_n.jpg?_nc_cat=101&ccb=1-7&_nc_sid=5f2048&_nc_ohc=qH4gXtzosEIAX-bnPn9&_nc_ht=scontent-lga3-2.xx&oh=00_AfBjaXSl7_RllFNdbVdcZH93dB9wdLWVNXZ7rL1CKOjmug&oe=6607ED04 align="center")

![](https://scontent-lga3-2.xx.fbcdn.net/v/t39.30808-6/432779624_1306464123607497_4444986124431969579_n.jpg?_nc_cat=101&ccb=1-7&_nc_sid=5f2048&_nc_ohc=dNze4KTg_REAX89wKtR&_nc_ht=scontent-lga3-2.xx&oh=00_AfBEpkmGqpjHXtHDcI9XaKMKtKyqIjj8lZMxjqyqaScK-w&oe=6607ADD7 align="center")

![](https://scontent-lga3-1.xx.fbcdn.net/v/t39.30808-6/434212301_1306464120274164_8572841837661064770_n.jpg?_nc_cat=108&ccb=1-7&_nc_sid=5f2048&_nc_ohc=VC3D8JOX3EgAX-6bWUj&_nc_ht=scontent-lga3-1.xx&oh=00_AfDiZFima61IGgQ9eN2Eytn-VRPLdu_n8eV2Tqn9isXjoQ&oe=66094070 align="center")

## Code

### p5js

```javascript
function setup() {
  createCanvas(windowWidth, windowHeight);

  //PROMPT
  x1 = prompt("choose a number between 0 and 159999");
  x2 = prompt("choose another number between 0 and 159999");
  x3 = prompt("choose a number larger than 159999 or smaller than 0");
  x4 = prompt("choose another number between 8000 and 159999");
  x5 = prompt("choose any number");
}

//Font
let usedFont = ["fantasy", "monospace", "georgia", "Courier New"];

//ARRAYS For Colors
let fillnumber = ["orange", "yellow", "gold", "red", "pink", "salmon", "coral"];
let fillnumber2 = [
  "blue",
  "teal",
  "skyblue",
  "navy",
  "turquoise",
  "royalblue",
  "midnightblue",
];

function draw() {
  

  
  // numbers in based 20 translation
  let numbers = [
    based_multi(x1, 20),
    based_multi(x2, 20),
    based_multi(x3, 20),
    based_multi(x4, 20),
    based_multi(x5, 20),
  ];

  background("black");
  textSize(35);

  //Varied Framerate
  frameRate(Math.cbrt((second() % 35) + 3));

  //Nested for loops to get grid like factor
  for (let i = 0; i < windowWidth; i = i + 125) {
    for (let j = 0; j < windowHeight; j = j + 150) {
      if (i % 15 > 7) {
        textFont(random(usedFont));
        stroke(random(fillnumber));
        strokeWeight((second() % 30) + 5);
        fill(random(fillnumber2));
        text(random(numbers), i + random(35, 44), j + 10);
      } else {
        textFont(random(usedFont));
        stroke(random(fillnumber2));
        strokeWeight(random(second() % 30) + 5);
        fill(random(fillnumber));
        text(random(numbers), i + 10, j + random(27, 3) + (second() % 3));
      }
    }
  }
}
// allow for fullscreen without switching
function mousePressed() {
  if (
    mouseX > 0 &&
    mouseX < windowWidth &&
    mouseY > 0 &&
    mouseY < windowHeight
  ) {
    let fs = fullscreen();
    fullscreen(!fs);
  }
}

//allows for translation into any base system
//takes an int I and translates it to a
function based_multi(i, b) {
  return Math.abs(i).toString(b);
}
```

### Hydra

```javascript
s0.initScreen()

src(s0).pixelate([15,30,100,500,1000,10000].smooth(),[15,30,45,100,1000,10000].smooth()).repeat(10,10)
.diff(src(s0)
.scale([1,1.5,2].smooth())).out()
```

### SonicPi

Tweaked Code & Sound (by Adding a different random seed generator) from a previous Genuary Submission: [https://blog.illestpreacha.com/genuary2023generativemusic](https://blog.illestpreacha.com/genuary2023generativemusic)

```ruby
#Two chord based functions, one runs on a random assortment, while the other one iterates

def chordsChoose(notes,minMaj,minMaj2,timeChord,dc,st)
  play chord(notes.choose, minMaj,decay: dc, sustain: st)
  play_pattern_timed chord(timeChord, minMaj2), [0.25,0.5].choose
  sleep [1,0.5,0.25,0.5,0.25,1].tick
end

def chordsTick(notes,minMaj,minMaj2,timeChord,dc,ak)
  play chord(notes.choose, minMaj,decay: dc, attack: ak)
  play_pattern_timed chord(timeChord, minMaj2), [0.25,0.5].tick
  sleep [1,0.75,0.5, 0.25].choose
end

#function for the arrangement

def arrangement(sound,bpm,preeffect,intensity,intensity2,loop,effect,effect2,effect3,effect4)
  
  use_random_seed Time.now.to_i
  
  use_synth sound
  use_bpm bpm
  
  with_fx preeffect,mix: intensity do
    live_loop loop do
      
      with_fx effect, mix: intensity2 do
        chordsChoose([:c4,:f4],:minor,:major,[:c5,:c5].tick,0,dice(3))
        chordsTick([:d3,:f3],:major,:major,[:f4,:d4].choose,2,1)
      end
      
      with_fx effect2, mix: 0.2 do
        chordsTick([:g3,:a3,:c3],:major,:major,[:g4,:f4].choose,3,dice(3))
        chordsTick([:e4,:a4,:c4],:major,:major,[:g4,:f4].choose,1,2)
      end
      
      with_fx effect3 do
        chordsChoose([:a3,:g3],:minor,:major,[:a4,:a4].tick,0,dice(3))
        chordsTick([:b2,:d2,:f4],:major,:major,[:g4,:f4,:d4].tick,1,dice(2))
      end
      
      with_fx effect4, mix: 0.1 do
        chordsTick([:f3,:b3],:major,:major,[:f4,:d4].choose,0,2)
        chordsTick([:g3,:a3,:c3],:major,:major,[:g4,:f4].choose,3,1)
        chordsTick([:d3,:b3],:major,:major,[:f4,:d4].choose,2,3)
      end
      
    end
  end
end

#treating every arrangement function as if it was a member of an ochestra



arrangement(:piano,60,:hpf,0.2,0.4,:arrangement1,:ixi_techno,:ping_pong,:ixi_techno,:ixi_techno)
arrangement([:fm,:prophet,:pretty_bell].choose,30,:lpf,0.3,0.5,:arrangement2,:ixi_techno,:gverb,:ixi_techno,:krush)
arrangement(:piano,30,:hpf,rrand(0.2,0.3),0.4,:arrangement3,:ixi_techno,:pitch_shift,:ixi_techno,:krush)
arrangement(:piano,15,:ping_pong,rrand(0.1,0.3),0.5,:arrangement4,:ixi_techno,:vowel,:ixi_techno,:ixi_techno)
arrangement([:fm,:prophet,:pretty_bell].choose,15,:ping_pong,rrand(0.1,0.3),0.5,:arrangement5,:ixi_techno,:pitch_shift,:ixi_techno,:ixi_techno)
arrangement(:chipbass,30,:vowel,rrand(0.1,0.3),0.5,:arrangement6,:ixi_techno,:pitch_shift,:ixi_techno,:ixi_techno)
arrangement(:dark_ambience,45,:whammy,rrand(0.2,0.7),0.4,:arrangement7,:ixi_techno,:ping_pong,:ixi_techno,:ixi_techno)
arrangement(:chipbass,15,:vowel,rrand(0.3,0.5),0.5,:arrangement8,:ixi_techno,:pitch_shift,:ixi_techno,:ixi_techno)
```

```ruby
#reading of the DipInCodeFirstService
#for csvs larger than 10 mbs use the for reach


require 'csv'

#naming the Dataset DipInCode and going to read the file
Dip = CSV.parse(File.read("C:/Colorscape/DipInCode/SonicPi_CodeBase/Model/DipInCode_FirstService.csv"), headers: true)

#Getting the Ingredients
Merlot = Dip[24]

#Dip[foodname][column].to_f , need to.f as it is to float

with_fx :vowel do
  live_loop :Merlot1 do
    use_bpm Merlot["Red"].to_f
    sample :sn_dub, rate: dice(Merlot["Yellow"].to_f/Merlot["Key"].to_f)  if spread(Merlot["Blue%"].to_f,Merlot["Green%"].to_f).tick
    sample :ambi_dark_woosh,rate: rrand(Merlot["y2"].to_f,Merlot["Red"].to_f/Merlot["Blue"].to_f)  if spread(Merlot["H-Lab1"].to_f,Merlot["CIE-L"].to_f).reverse.mirror
    sleep [Merlot["x2"].to_f,Merlot["Yellow"].to_f/Merlot["Mangeta"].to_f,Merlot["Saturation2"].to_f/Merlot["Lightness"].to_f].choose
  end
end

with_fx :ixi_techno do
  live_loop :Merlot2 do
    use_bpm Merlot["Blue"].to_f
    with_fx :reverb do
      sample :ambi_choir, rate: rrand(Merlot["y2"].to_f,Merlot["Red"].to_f/Merlot["Blue"].to_f) if spread(Merlot["H-Lab1"].to_f,Merlot["CIE-L"].to_f).reverse.mirror
      sleep [Merlot["x2"].to_f,Merlot["Green%"].to_f/Merlot["Blue%"].to_f].choose
    end
  end
end

with_fx :gverb do
  live_loop :Merlot3 do
    use_bpm Merlot["Green"].to_f
    sample :elec_blip, rate: dice(Merlot["Yellow"].to_f/Merlot["Key"].to_f)  if spread(Merlot["Blue%"].to_f,Merlot["Green%"].to_f).tick
    sample :ambi_dark_woosh,rate: rrand(Merlot["y2"].to_f,Merlot["Red"].to_f/Merlot["Blue"].to_f)  if spread(Merlot["H-Lab1"].to_f,Merlot["CIE-L"].to_f).reverse.mirror
    sleep [Merlot["x2"].to_f,Merlot["Yellow"].to_f/Merlot["Mangeta"].to_f,Merlot["Saturation2"].to_f/Merlot["Lightness"].to_f].choose
  end
end

with_fx :distortion do
  live_loop :Merlot4 do
    use_bpm Merlot["Red"].to_f
    with_fx :reverb do
      sample :ambi_choir, rate: rrand(Merlot["y2"].to_f,Merlot["Red"].to_f/Merlot["Blue"].to_f) if spread(Merlot["H-Lab1"].to_f,Merlot["CIE-L"].to_f).reverse.mirror
      sleep [Merlot["x2"].to_f,Merlot["Green%"].to_f/Merlot["Blue%"].to_f].choose
    end
  end
end
```