diff draw_smart.pde @ 225:1c9deae71fb1

Cleanups.
author Matti Hamalainen <ccr@tnsp.org>
date Wed, 05 Sep 2018 20:28:23 +0300
parents 934934bb1fbb
children 1d9f9c3d8ab1
line wrap: on
line diff
--- a/draw_smart.pde	Wed Sep 05 20:08:57 2018 +0300
+++ b/draw_smart.pde	Wed Sep 05 20:28:23 2018 +0300
@@ -9,7 +9,8 @@
     if (g_multic == 1 || g_multic == 2)
         return;
 
-    if (g_attrimode == 0) {
+    if (g_attrimode == 0)
+    {
         mat = 8;
         mulu = 1;
         maxxy = Y;
@@ -64,12 +65,14 @@
     yb = 0;
     xx = int(xx / 8);
 
-    if (g_attrimode == 1) {
+    if (g_attrimode == 1)
+    {
         yy = chop8(yy);
         ya = 0;
         yb = 7;
     } //zx spec etc
-    if (g_attrimode == 0) {
+    if (g_attrimode == 0)
+    {
         ya = 0;
         yb = 0;
     } //msx
@@ -309,10 +312,12 @@
 //reasons the background color for each char as you draw
 //=changed
 
-void fixattr(int x, int y, int foreg, int backg) {
+void fixattr(int x, int y, int foreg, int backg)
+{
     int bad, cad, miny, maxy;
 
-    if (g_britemode == 1) {
+    if (g_britemode == 1)
+    {
         if (foreg == 8 || backg == 8 || foreg == 0 || backg == 0) return;
     }
 
@@ -321,20 +326,24 @@
     miny = maxy;
     y = chop8(y);
 
-    if (g_attrimode == 1) {
+    if (g_attrimode == 1)
+    {
         miny = 0;
         maxy = 7;
     }
 
-    for (int i = miny; i <= maxy; i++) {
+    for (int i = miny; i <= maxy; i++)
+    {
         bad = 65536 + int(x / 8) + (y + i) * MX;
         cad = bad + MX * (MY * 8);
-        if (foreg >= 0) {
+        if (foreg >= 0)
+        {
             g_map[bad] = byte(foreg);
             if (foreg >= 8 && g_map[cad] < 8) g_map[cad] = byte(g_map[cad] + 8);
             if (foreg < 8 && g_map[cad] >= 8) g_map[cad] = byte(g_map[cad] - 8);
         }
-        if (backg >= 0) {
+        if (backg >= 0)
+        {
             g_map[cad] = byte(backg);
             if (backg >= 8 && g_map[bad] < 8) g_map[bad] = byte(g_map[bad] + 8);
             if (backg < 8 && g_map[bad] >= 8) g_map[bad] = byte(g_map[bad] - 8);
@@ -349,16 +358,20 @@
 //or if forcecolor is pressed.
 //bit different for C64 and PLUS4M
 
-void skaveri(int x, int y, int foreg, int backg) {
+void skaveri(int x, int y, int foreg, int backg)
+{
     int mx = int(x / 8);
     int my = int(y / 8);
     if (g_control == false) return;
     int cc = easygetcolor(x, y);
     mx = mx * 8;
     my = my * 8;
-    for (int xx = 0; xx <= 7; xx++) {
-        for (int yy = 0; yy <= 7; yy++) {
-            if (easygetcolor(mx + xx, my + yy) == cc) {
+    for (int xx = 0; xx <= 7; xx++)
+    {
+        for (int yy = 0; yy <= 7; yy++)
+        {
+            if (easygetcolor(mx + xx, my + yy) == cc)
+            {
                 g_map[1024 + mx + xx + (my + yy) * X] = byte(foreg);
             }
         }
@@ -367,7 +380,8 @@
 }
 
 
-void mkaveri(int x, int y, int foreg, int backg) {
+void mkaveri(int x, int y, int foreg, int backg)
+{
     int mx = int(x / 8);
     int my = int(y / 8);
     int ad, bad, cad, dad, b0, b1;
@@ -395,7 +409,8 @@
     free2 = 1;
     f3 = int(g_map[cad + 2000]);
     free3 = 1;
-    if (g_machine == PLUS4M) {
+    if (g_machine == PLUS4M)
+    {
         free3 = 0;
         suffocatelimit = 3;
         f3 = int(g_map[2]);
@@ -403,29 +418,38 @@
 
     if (foreg == g_map[1] && g_control == false) return;
 
-    if (foreg != f1 && foreg != f2 && foreg != f3 || g_control == true) {
-        for (int yy = 0; yy <= 7; yy++) {
-            for (int xx = 0; xx <= 3; xx++) {
+    if (foreg != f1 && foreg != f2 && foreg != f3 || g_control == true)
+    {
+        for (int yy = 0; yy <= 7; yy++)
+        {
+            for (int xx = 0; xx <= 3; xx++)
+            {
                 ad = 1024 + (mx * 8 + xx * 2) + (my * 8 + yy) * X;
-                if (g_map[ad] == 0 && g_map[ad + 1] == 0) { //00 = 00
+                if (g_map[ad] == 0 && g_map[ad + 1] == 0)
+                { //00 = 00
                     if (f0 == f) order = 4;
                 }
-                if (g_map[ad] == 1 && g_map[ad + 1] == 0) { //01 = 10
+                if (g_map[ad] == 1 && g_map[ad + 1] == 0)
+                { //01 = 10
                     numb = numb | 1;
                     free1 = 0;
                     if (f1 == f) order = 1;
                 }
-                if (g_map[ad] == 0 && g_map[ad + 1] == 1) { //02 = 01
+                if (g_map[ad] == 0 && g_map[ad + 1] == 1)
+                { //02 = 01
                     numb = numb | 2;
                     free2 = 0;
                     if (f2 == f) order = 2;
                 }
-                if (g_map[ad] == 1 && g_map[ad + 1] == 1) { //03 = 11
-                    if (g_machine == C64M) {
+                if (g_map[ad] == 1 && g_map[ad + 1] == 1)
+                { //03 = 11
+                    if (g_machine == C64M)
+                    {
                         numb = numb | 4;
                         free3 = 0;
                     }
-                    if (f3 == f) {
+                    if (f3 == f)
+                    {
                         order = 3;
                         targetbit0 = 1;
                         targetbit1 = 1;
@@ -438,52 +462,65 @@
         if (order == 4) zoink = true;
         if (order == 3 && g_machine == PLUS4M) zoink = true;
 
-        if ((zoink || numb != suffocatelimit) && g_control == true) {
-            if (zoink) {
+        if ((zoink || numb != suffocatelimit) && g_control == true)
+        {
+            if (zoink)
+            {
                 //println("foreg:"+foreg+" f0:"+f0+" f1:"+f1+" f2:"+f2+" f3:"+f3+" free1:"+free1+" free2:"+free2+" free3:"+free3);
                 b0 = -1;
                 b1 = -1;
-                if (foreg == f1 && free1 == 0) {
+                if (foreg == f1 && free1 == 0)
+                {
                     b0 = 1;
                     b1 = 0;
                 }
-                if (foreg == f2 && free2 == 0) {
+                if (foreg == f2 && free2 == 0)
+                {
                     b0 = 0;
                     b1 = 1;
                 }
-                if (foreg == f3 && g_machine == C64M && free3 == 0) {
+                if (foreg == f3 && g_machine == C64M && free3 == 0)
+                {
                     b0 = 1;
                     b1 = 1;
                 }
-                if (foreg == f3 && g_machine == PLUS4M) {
+                if (foreg == f3 && g_machine == PLUS4M)
+                {
                     b0 = 1;
                     b1 = 1;
                 }
 
-                if (free1 == 1) {
+                if (free1 == 1)
+                {
                     free2 = 0;
                     free3 = 0;
                     b0 = 1;
                     b1 = 0;
                     g_map[cad] = byte(foreg);
                 }
-                if (free2 == 1) {
+                if (free2 == 1)
+                {
                     free3 = 0;
                     b0 = 0;
                     b1 = 1;
                     g_map[cad + 1000] = byte(foreg);
                 }
-                if (free3 == 1) {
+                if (free3 == 1)
+                {
                     b0 = 1;
                     b1 = 1;
                     g_map[cad + 2000] = byte(foreg);
                 }
 
-                for (int yy = 0; yy <= 7; yy++) {
-                    for (int xx = 0; xx <= 3; xx++) {
+                for (int yy = 0; yy <= 7; yy++)
+                {
+                    for (int xx = 0; xx <= 3; xx++)
+                    {
                         ad = 1024 + (mx * 8 + xx * 2) + (my * 8 + yy) * X;
-                        if (g_map[ad] == targetbit0 && g_map[ad + 1] == targetbit1) {
-                            if (b0 >= 0) {
+                        if (g_map[ad] == targetbit0 && g_map[ad + 1] == targetbit1)
+                        {
+                            if (b0 >= 0)
+                            {
                                 g_map[ad] = byte(b0);
                                 g_map[ad + 1] = byte(b1);
                             }
@@ -495,82 +532,109 @@
 
         //if all color positions are filled, we'll just change the existing one
 
-        if (numb == suffocatelimit || g_control == true) {
-            if (order == 1) {
+        if (numb == suffocatelimit || g_control == true)
+        {
+            if (order == 1)
+            {
                 g_map[cad] = byte(foreg);
             } //10==1
-            if (order == 2) {
+            if (order == 2)
+            {
                 g_map[cad + 1000] = byte(foreg);
             } //01==2
-            if (order == 3 && g_machine == C64M) {
+            if (order == 3 && g_machine == C64M)
+            {
                 g_map[cad + 2000] = byte(foreg);
             } //11==3
         }
 
         //color redundancy check
 
-        for (int yy = 0; yy <= 7; yy++) {
-            for (int xx = 0; xx <= 3; xx++) {
+        for (int yy = 0; yy <= 7; yy++)
+        {
+            for (int xx = 0; xx <= 3; xx++)
+            {
                 ad = 1024 + (mx * 8 + xx * 2) + (my * 8 + yy) * X;
 
-                if (g_machine == C64M) {
-                    if (g_map[cad] == g_map[cad + 2000]) {
-                        if (g_map[ad] == 1 && g_map[ad + 1] == 1) {
+                if (g_machine == C64M)
+                {
+                    if (g_map[cad] == g_map[cad + 2000])
+                    {
+                        if (g_map[ad] == 1 && g_map[ad + 1] == 1)
+                        {
                             g_map[ad] = 1;
                             g_map[ad + 1] = 0;
                         }
                     }
-                    if (g_map[cad + 1000] == g_map[cad + 2000]) {
-                        if (g_map[ad] == 1 && g_map[ad + 1] == 1) {
+                    if (g_map[cad + 1000] == g_map[cad + 2000])
+                    {
+                        if (g_map[ad] == 1 && g_map[ad + 1] == 1)
+                        {
                             g_map[ad] = 0;
                             g_map[ad + 1] = 1;
                         }
                     }
                 }
 
-                if (g_map[cad] == g_map[cad + 1000]) {
-                    if (g_map[ad] == 0 && g_map[ad + 1] == 1) {
+                if (g_map[cad] == g_map[cad + 1000])
+                {
+                    if (g_map[ad] == 0 && g_map[ad + 1] == 1)
+                    {
                         g_map[ad] = 1;
                         g_map[ad + 1] = 0;
                     }
                 }
-                if (g_map[1] == g_map[cad]) {
-                    if (g_map[ad] == 1 && g_map[ad + 1] == 0) {
+                if (g_map[1] == g_map[cad])
+                {
+                    if (g_map[ad] == 1 && g_map[ad + 1] == 0)
+                    {
                         g_map[ad] = 0;
                         g_map[ad + 1] = 0;
                     }
                 }
-                if (g_map[1] == g_map[cad + 1000]) {
-                    if (g_map[ad] == 0 && g_map[ad + 1] == 1) {
+                if (g_map[1] == g_map[cad + 1000])
+                {
+                    if (g_map[ad] == 0 && g_map[ad + 1] == 1)
+                    {
                         g_map[ad] = 0;
                         g_map[ad + 1] = 0;
                     }
                 }
 
-                if (g_machine == PLUS4M) {
-                    if (g_map[2] == g_map[cad]) {
-                        if (g_map[ad] == 1 && g_map[ad + 1] == 0) {
+                if (g_machine == PLUS4M)
+                {
+                    if (g_map[2] == g_map[cad])
+                    {
+                        if (g_map[ad] == 1 && g_map[ad + 1] == 0)
+                        {
                             g_map[ad] = 1;
                             g_map[ad + 1] = 1;
                         }
                     }
-                    if (g_map[2] == g_map[cad + 1000]) {
-                        if (g_map[ad] == 0 && g_map[ad + 1] == 1) {
+                    if (g_map[2] == g_map[cad + 1000])
+                    {
+                        if (g_map[ad] == 0 && g_map[ad + 1] == 1)
+                        {
                             g_map[ad] = 1;
                             g_map[ad + 1] = 1;
                         }
                     }
-                    if (g_map[1] == g_map[2]) {
-                        if (g_map[ad] == 1 && g_map[ad + 1] == 1) {
+                    if (g_map[1] == g_map[2])
+                    {
+                        if (g_map[ad] == 1 && g_map[ad + 1] == 1)
+                        {
                             g_map[ad] = 0;
                             g_map[ad + 1] = 0;
                         }
                     }
                 }
 
-                if (g_machine == C64M) {
-                    if (g_map[1] == g_map[cad + 2000]) {
-                        if (g_map[ad] == 1 && g_map[ad + 1] == 1) {
+                if (g_machine == C64M)
+                {
+                    if (g_map[1] == g_map[cad + 2000])
+                    {
+                        if (g_map[ad] == 1 && g_map[ad + 1] == 1)
+                        {
                             g_map[ad] = 0;
                             g_map[ad + 1] = 0;
                         }
@@ -595,11 +659,14 @@
     int mx = int(x / 8);
     int my = int(y / 8);
 
-    if (g_attrimode == 1) {
+    if (g_attrimode == 1)
+    {
         k_max = 64;
         miny = 0;
         maxy = 7;
-    } else {
+    }
+    else
+    {
         k_max = 8;
         miny = chop8(y);
         maxy = y - miny;
@@ -619,7 +686,8 @@
         for (int yy = miny; yy <= maxy; yy++)
         {
             ad = 1024 + (mx * 8) + (my * 8 + yy) * X;
-            for (int xx = 0; xx <= 7; xx++) {
+            for (int xx = 0; xx <= 7; xx++)
+            {
                 val = val + g_map[ad + xx];
             }
         }
@@ -635,27 +703,36 @@
         farge0 = g_map[bad]; //if(g_britemode==1&&farge0==8){farge0=0;}
         farge1 = g_map[cad]; //if(g_britemode==1&&farge1==8){farge1=0;}
 
-        if (g_britemode == 1) {
-            if (farge0 < 8) {
-                if (foreg == farge0 + 8) {
+        if (g_britemode == 1)
+        {
+            if (farge0 < 8)
+            {
+                if (foreg == farge0 + 8)
+                {
                     fixattr(x, y, foreg, -1);
                     return;
                 }
             }
-            if (farge1 < 8) {
-                if (foreg == farge1 + 8) {
+            if (farge1 < 8)
+            {
+                if (foreg == farge1 + 8)
+                {
                     fixattr(x, y, -1, foreg);
                     return;
                 }
             }
-            if (farge0 >= 8) {
-                if (foreg == farge0 - 8) {
+            if (farge0 >= 8)
+            {
+                if (foreg == farge0 - 8)
+                {
                     fixattr(x, y, foreg, -1);
                     return;
                 }
             }
-            if (farge1 >= 8) {
-                if (foreg == farge1 - 8) {
+            if (farge1 >= 8)
+            {
+                if (foreg == farge1 - 8)
+                {
                     fixattr(x, y, -1, foreg);
                     return;
                 }
@@ -674,31 +751,40 @@
     if (g_britemode == 1 && piksuf == 8) piksuf = 0;
     bad = 0;
     cad = 0;
-    for (int yy = miny; yy <= maxy; yy++) {
+    for (int yy = miny; yy <= maxy; yy++)
+    {
         bad = 65536 + mx + (my * 8) * MX + yy * MX;
         cad = bad + MX * (MY * 8);
         fg = g_map[bad];
         if (g_britemode == 1 && fg == 8) fg = 0;
         bg = g_map[cad];
         if (g_britemode == 1 && bg == 8) bg = 0;
-        if (piksuf == fg) {
+        if (piksuf == fg)
+        {
             g_map[bad] = byte(foreg);
-            if (g_britemode == 1) {
-                if (foreg > 7 && g_map[cad] < 8 && g_map[cad] != 0) {
+            if (g_britemode == 1)
+            {
+                if (foreg > 7 && g_map[cad] < 8 && g_map[cad] != 0)
+                {
                     g_map[cad] = byte(g_map[cad] + 8);
                 }
-                if (foreg < 8 && g_map[cad] > 8 && foreg != 0) {
+                if (foreg < 8 && g_map[cad] > 8 && foreg != 0)
+                {
                     g_map[cad] = byte(g_map[cad] - 8);
                 }
             }
         }
-        if (piksuf == bg) {
+        if (piksuf == bg)
+        {
             g_map[cad] = byte(foreg);
-            if (g_britemode == 1) {
-                if (foreg > 7 && g_map[bad] < 8 && g_map[bad] != 0) {
+            if (g_britemode == 1)
+            {
+                if (foreg > 7 && g_map[bad] < 8 && g_map[bad] != 0)
+                {
                     g_map[bad] = byte(g_map[bad] + 8);
                 }
-                if (foreg < 8 && g_map[bad] > 8 && foreg != 0) {
+                if (foreg < 8 && g_map[bad] > 8 && foreg != 0)
+                {
                     g_map[bad] = byte(g_map[bad] - 8);
                 }
             }
@@ -707,9 +793,12 @@
 
     // if the result is same color, zero the pixel data
 
-    if (g_map[bad] == g_map[cad]) {
-        for (int yy = miny; yy <= maxy; yy++) {
-            for (int xx = 0; xx <= 7; xx++) {
+    if (g_map[bad] == g_map[cad])
+    {
+        for (int yy = miny; yy <= maxy; yy++)
+        {
+            for (int xx = 0; xx <= 7; xx++)
+            {
                 ad = 1024 + (mx * 8 + xx) + (my * 8 + yy) * X;
                 g_map[ad] = byte(0);
             }
@@ -719,7 +808,8 @@
 }
 
 
-void kaveri_iq(int x, int y, int f1, int f2) {
+void kaveri_iq(int x, int y, int f1, int f2)
+{
     int k_xx, k_yy, k_ad, k_bad, k_ojox, k_ojoy, k_miny, k_maxy, k_xv, k_yv;
     int k_c1, k_c2, k_v0, k_v1, k_tipping, k_maximum, exist;
     byte k_p;
@@ -729,14 +819,19 @@
 
     exist = getabsa(x, y, 0);
 
-    if (g_britemode == 1) {
-        if (exist == 8) {
-            if (g_farge < 8) {
+    if (g_britemode == 1)
+    {
+        if (exist == 8)
+        {
+            if (g_farge < 8)
+            {
                 exist = 0;
             }
         }
-        if (exist == 0) {
-            if (g_farge > 7) {
+        if (exist == 0)
+        {
+            if (g_farge > 7)
+            {
                 exist = 0;
             }
         }
@@ -755,7 +850,8 @@
     k_maxy = k_miny;
     k_maximum = 8;
 
-    if (g_attrimode == 1) {
+    if (g_attrimode == 1)
+    {
         k_miny = 0;
         k_maxy = 7;
         k_tipping = 32;
@@ -767,7 +863,8 @@
     k_c1 = g_map[k_ad];
     k_c2 = g_map[k_bad];
 
-    if (g_britemode == 1) {
+    if (g_britemode == 1)
+    {
         if (k_c1 == 8) k_c1 = 0;
         if (k_c2 == 8) k_c2 = 0;
     }
@@ -775,12 +872,17 @@
     k_bad = 1024 + k_xx * 8 + k_yy * X;
 
     //do we have more 0's or 1's
-    for (k_yv = k_miny; k_yv <= k_maxy; k_yv++) {
+    for (k_yv = k_miny; k_yv <= k_maxy; k_yv++)
+    {
         k_ad = k_bad + k_yv * X;
-        for (k_xv = 0; k_xv <= 7; k_xv++) {
-            if (g_map[k_ad] == 1) {
+        for (k_xv = 0; k_xv <= 7; k_xv++)
+        {
+            if (g_map[k_ad] == 1)
+            {
                 k_v1++;
-            } else {
+            }
+            else
+            {
                 k_v0++;
             }
             k_ad++;
@@ -789,25 +891,31 @@
 
     //force color
 
-    if (g_control) {
+    if (g_control)
+    {
 
         k_v1 = k_tipping + 1;
 
-        if (k_c1 == exist) {
+        if (k_c1 == exist)
+        {
             k_c1 = g_farge;
             if (k_c1 == 8 && g_britemode == 1) k_c1 = 0;
         }
-        if (k_c2 == exist) {
+        if (k_c2 == exist)
+        {
             k_c2 = g_farge;
             if (k_c2 == 8 && g_britemode == 1) k_c2 = 0;
         }
 
-        if (g_britemode == 1) {
-            if (g_farge >= 8) {
+        if (g_britemode == 1)
+        {
+            if (g_farge >= 8)
+            {
                 if (k_c1 <= 7) k_c1 = k_c1 + 8;
                 if (k_c2 <= 7) k_c2 = k_c2 + 8;
             }
-            if (g_farge <= 7) {
+            if (g_farge <= 7)
+            {
                 if (k_c1 >= 8) k_c1 = k_c1 - 8;
                 if (k_c2 >= 8) k_c2 = k_c2 - 8;
             }
@@ -815,16 +923,20 @@
 
     }
 
-    if (k_v1 > k_tipping) {
-        for (k_yv = k_miny; k_yv <= k_maxy; k_yv++) {
+    if (k_v1 > k_tipping)
+    {
+        for (k_yv = k_miny; k_yv <= k_maxy; k_yv++)
+        {
             k_ad = 65536 + k_xx + (k_yy + k_yv) * MX;
             k_bad = k_ad + MX * (MY * 8);
             g_map[k_ad] = byte(k_c2);
             g_map[k_bad] = byte(k_c1);
         }
-        for (k_yv = k_miny; k_yv <= k_maxy; k_yv++) {
+        for (k_yv = k_miny; k_yv <= k_maxy; k_yv++)
+        {
             k_ad = 1024 + k_xx * 8 + (k_yy + k_yv) * X;
-            for (k_xv = 0; k_xv <= 7; k_xv++) {
+            for (k_xv = 0; k_xv <= 7; k_xv++)
+            {
                 k_p = g_map[k_ad];
                 g_map[k_ad] = byte(1 - k_p);
                 if (k_c1 == k_c2) g_map[k_ad] = byte(0);