Wyzwanie jest dwojakie:

Stwórz program, który buduje drzwi. ASCII, HTML lub w inny sposób

Spraw, by drzwi działały. Otwiera i zamyka

Można je otworzyć poprzez wejście lub interakcję!

• Drzwi niefunkcjonalne +5 punktów.
• Tylko otwarte drzwi +10 punktów.
• Interaktywne drzwi +15 punktów.
• Ozdobne drzwi +20 punktów. Oznacza to obracanie, dzielenie itp
• Animowane +20 punktów.
• <100 znaków +50 punktów.
• -100 punktów za korzystanie z programu specjalnie zaprojektowanego do rysowania lub animacji.

Jeśli masz kryteria, sugestie pozostaw je w komentarzach.

Przykład niefunkcjonalnych otwartych drzwi:

<?php
$idiots_in_room=true;

if($idiots_in_room)
{

$count=20;
$count2=7;
for($i=0;$i<$count;$i++)
{

if($i==0)
{
echo str_repeat("-",10);
if($i==0){echo ".";}
echo "\n";
}
elseif($i==9)
{
echo str_repeat("-",10);
echo str_repeat(" ",7)."o"."|";
echo "\n";
}
elseif($i<=9)
{

echo str_repeat("-",1).str_repeat(" ",8).str_repeat("-",1);

echo ($i<5) ? str_repeat(" ",$i*2)."\\" : str_repeat(" ",8)."|";
echo "\n";
}
elseif($i<=14)
{
if($i>9){echo str_repeat(" ",$i)."\\";}
echo str_repeat(" ",$count2--)."|";
echo "\n";
}

}
}

Przykładowe dane wyjściowe:

----------.
-        -  \
-        -    \
-        -      \
-        -        \
-        -        |
-        -        |
-        -        |
-        -        |
----------       o|
          \       |
           \      |
            \     |
             \    |
              \   |

JavaScript, 4380 znaków, 65 (?) Punktów

ASCII? Czek. HTML? Czek. Czy drzwi Czek. Otwierane drzwi? Czek. Interaktywny? Czek. Fantazyjny? Podwójne drzwi z odpowiednio ustawionymi zawiasami, mam nadzieję, że to się liczy. Ożywiony? Czek. Poniżej 100 znaków? Ha. Nie używasz urządzeń przeznaczonych do rysowania? Czek.

Demo na żywo. (Uwaga: w moich testach z Firefoksem kliknięcie drzwi więcej niż jeden raz nie działa - z jakiegoś powodu program obsługi zdarzeń nie uruchamia się ponownie i jestem zaskoczony, dlaczego; wskazanie, co zrobiłem źle, byłoby mile widziane. Chociaż możesz mimo to uruchomić to w Chrome, aby uzyskać przyzwoitą wydajność JS).

<title>Door</title>
<pre onmouseup="turn();" style="display: table; margin: auto; font-family: 'Monaco', monospace; font-size: 0.6em; line-height: 0.7em;">
</pre>
<p>Click doors to open or close.</p>
<script>

  // Appearance of hit surface - global used to avoid allocating a record to return
  var mat;

  // Scene construction tools
  function box(size,ms) {
    return function (x, y, z) {
      var vdist0 = Math.abs(x) - size[0];
      var vdist1 = Math.abs(y) - size[1];
      var vdist2 = Math.abs(z) - size[2];
      mat = vdist0 > vdist1 && vdist0 > vdist2 ? ms[0] :
            vdist1 > vdist0 && vdist1 > vdist2 ? ms[1] :
            ms[2];
      return Math.max(vdist0, vdist1, vdist2);
    };
  }
  function translate(vec, obj) {
    var dx = vec[0];
    var dy = vec[1];
    var dz = vec[2];
    return function (x, y, z) { return obj(x - dx, y - dy, z - dz); };
  }
  function mirror(obj) {
    return function (x, y, z) { return obj(-x, y, z); };
  }
  function spin(obj) {
    return function (x, y, z) {
      var a = Date.now() / 1000;
      var s = Math.sin(a);
      var c = Math.cos(a);
      return obj(
        x * c + z * s,
        y,
        x * -s + z * c
      );
    };
  }
  function doorturn(obj) {
    return function (x, y, z) {
      var a = pos;
      var s = Math.sin(a);
      var c = Math.cos(a);
      return obj(
        x * c + z * s,
        y,
        x * -s + z * c
      );
    };
  }
  function rotx(a, obj) {
    return function (x, y, z) {
      var s = Math.sin(a);
      var c = Math.cos(a);
      return obj(
        x,
        y * c + z * s,
        y * -s + z * c
      );
    };
  }
  function roty(a, obj) {
    return function (x, y, z) {
      var s = Math.sin(a);
      var c = Math.cos(a);
      return obj(
        x * c + z * s,
        y,
        x * -s + z * c
      );
    };
  }
  function union(as, bs) {
    return function (x, y, z) {
      var a = as(x, y, z); var am = mat;
      var b = bs(x, y, z);
      if (a < b) {
        mat = am;
        return a;
      } else {
        return b;
      }
    };
  }

  // Display parameters
  var vw = 80, vh = 80;
  var timestep = 1/30;

  // Scene
  var wallhwidth = 30;
  var wallhheight = 35;
  var wallmat = [";", "\u2014", ":"];
  var dhwidth = 10;
  var dhheight = 20;
  var hthick = 2;
  var door = translate([-dhwidth*2, 0, 0], doorturn(translate([hthick, 0, dhwidth], box([hthick, dhheight, dhwidth], [".", "\u2014", "|"]))));
  var doors = union(door, mirror(door));
  var wall = union(
    union(
      translate([dhwidth*2+wallhwidth, 0, -hthick], box([wallhwidth, wallhheight, hthick], wallmat)),
      translate([-dhwidth*2-wallhwidth, 0, -hthick], box([wallhwidth, wallhheight, hthick], wallmat))),
    translate([0, wallhheight-(wallhheight-dhheight)/2, -hthick], box([dhwidth*2, (wallhheight-dhheight)/2, hthick], wallmat)));
  var floor = translate([0, -dhheight - 1.1, 0], box([100, 1, 100], ["/","/","/"]));
  var sill = translate([0, -dhheight - 1, -hthick], box([dhwidth*2, 1, hthick], ["\\","%","\\"]));
  var sbox = translate([0, 0, -12], spin(box([8, 8, 8], ["x", "y", "z"])))
  var scene = union(sbox, union(union(wall, doors), union(floor, sill)));
  var view = translate([vw/2, vh/2, -100], rotx(0.2, roty(-0.6, scene)));

  // Animation state
  var pos = -Math.PI/2;
  var dpos = 0;
  var interval;

  // Main loop function
  function r() {
    // Update state
    pos += dpos * timestep;
    if (Math.abs(pos) >= Math.PI/2) {
      dpos = 0;
      pos = Math.PI/2 * pos / Math.abs(pos);
      if (pos < 0) { // no animation needed
        clearInterval(interval); interval = undefined;
      }
    }

    // Render scene
    var t = [];
    for (var y = vh - 1; y >= 0; y--) {
      for (var x = 0; x < vw; x++) {
        var z = 0, distance;
        while ((distance = view(x,y,z)) > 0.12) {
          z -= distance;
          if (!isFinite(z) || z < -1000) {
            mat = " ";
            break;
          }
        }
        t.push(mat);
      }
      t.push("\n");
    }
    document.getElementsByTagName("pre")[0].textContent = t.join("");
  }

  // Click handler
  function turn() {
    if (dpos !== 0) {
      dpos *= -1;
    } else {
      dpos = (pos < 0 ? 1 : -1) * 2.3;
    }
    if (!interval) {
      interval = setInterval(r, timestep*1000);
    }
  }

  // Render initial state
  r();
</script>

Po zamknięciu drzwi wyglądają tak:

HTML i CSS3, 55 punktów

Fantazyjne, interaktywne, animowane drzwi to chyba 55 punktów.

Tak, otwierają się jak każde inne drzwi, ale jeśli drzwi przesuwne są tak fantazyjne, dlaczego drzwi obrotowe nie? Jeśli obrotowe nie są fantazyjne, cóż, drzwi przesuwne nie stanowią problemu:)

Demo jest dostępne na stronie http://result.dabblet.com/gist/3132160/ac475112dbba493d2dd7d98493d4f4ceaa209a7c . Kliknij klamkę, aby otworzyć i zamknąć. Nie wymaga JavaScript; to tylko magia CSS3.

#wall {
    background-color: #eee;
    bottom: 0;
    left: 0;
    position: absolute;
    right: 0;
    top: 0;
    transform: rotateX(-10deg);
    transform-origin: 0 100%;
    transform-style: preserve-3d;
}

#door-container {
    background-color: black;
    height: 100%;
    margin: 0 auto;
    width: 300px;
}

#door {
    background-color: brown;
    height: 100%;
    margin: auto;
    position: relative;
    transform-origin: 0 0;
    transition: transform 0.5s ease;
    width: 300px;
}

#door .knob {
    background-color: gold;
    border-radius: 10px;
    height: 20px;
    margin-top: -10px;
    position: absolute;
    right: 10px;
    top: 50%;
    width: 20px;
}

#open:target + #wall #door {
    transform: rotateY(-145deg);
}

#open:target + #wall #open-link {
    display: none;
}

#close-link {
    display: none;
}

#open:target + #wall #close-link {
    display: inline;
}

<span id="open"></span>
<div id="wall">
    <div id="door-container">
        <div id="door">
            <a href="#open" id="open-link" class="knob"></a>
            <a href="#closed" id="close-link" class="knob"></a>
        </div>
    </div>
</div>

Mathematica 271 znaków

Manipulate[a = {0, 0, 0}; b = {0, 0, h}; p = Polygon; c = Cuboid; t = Rotate;Graphics3D[{c@{{-w - 1, 0, 0}, {-w, 1, h}}, c@{{w + 1, 0, 0}, {w, 1, h}},t[p@{a, b, {-w, 0, h}, {-w, 0, 0}}, r, {0, 0, 1}, {- 2 w/3, -w/3, 0}], t[p@{a, b, {w, 0, h}, {w, 0, 0}}, -r, {0, 0, 1}, { 2 w/3, -w/3, 0}]}],{{r, 0}, 0, 3/2}, {{w, 2}, 1, 3}, {{h, 4}, 3, 5}]

Podwójne drzwi

• otwieranie przez obrót od zera do 90 stopni (za pomocą suwaka r)
• ich wysokość i szerokość można ustawić za pomocą suwaków ( hi w).
• są w środowisku oświetlenia 3D
• można interaktywnie obracać, aby oglądać pod różnymi kątami.

Kod oparty jest na programie Sándora Kabala.

Python - 65 punktów, 86 znaków

Interaktywne i mniej niż 100 znaków.

Czeka na wejście i pokazuje drzwi . Prawidłowe dane wejściowe to „otwórz” i „zamknij” i „pa”.

g,s=1,'open close'
while g:
 i=raw_input()
 print '_'+'/_ '[s.find(i)/5]+'_'
 g=i in s

Mathematica 127 znaków

Jest to bardziej usprawniona implementacja niż ta, którą przedłożyłem wcześniej. Ma pojedyncze drzwi. Pojedyncze drzwi

• otwiera się przez obrót od zera do 90 stopni (za pomocą suwaka o)
• jest w środowisku oświetlenia 3D
• można interaktywnie obracać, aby oglądać pod różnymi kątami.

Wykorzystuje jednak stałą wysokość i szerokość drzwi.

Manipulate[a = {0, 0, 0}; Graphics3D[{Tube[{a, {1, 0, 0}, {1, 0, 2}, {0, 0, 2}, a}, .03],Rotate[Cuboid@{a, {1, -.1, 2}}, o, {0, 0, 1}, a]}], {o, 0, -Pi/2}]