home *** CD-ROM | disk | FTP | other *** search
/ Champak 40 / Vol 40.iso / games / ws_tetri.swf / scripts / frame_45 / DoAction.as
Encoding:
Text File  |  2007-03-21  |  12.6 KB  |  508 lines
  1. function steinFarbe()
  2. {
  3.    var _loc1_ = Math.round(Math.random() * 6);
  4.    return _loc1_;
  5. }
  6. function baueSpielfeld()
  7. {
  8.    var _loc3_ = 0;
  9.    while(_loc3_ < spielfeld.zeilen)
  10.    {
  11.       var _loc2_ = 0;
  12.       while(_loc2_ < spielfeld.spalten)
  13.       {
  14.          var _loc1_ = _loc3_ * spielfeld.spalten + _loc2_;
  15.          this.mc_feld.attachMovie("mc_stein",_loc1_,_loc1_ + spielfeld.tiefe,{_x:_loc2_ * stein.breite,_y:_loc3_ * stein.hoehe,feldnr:_loc1_});
  16.          spielfeld.feld[_loc1_] = 0;
  17.          _loc2_ = _loc2_ + 1;
  18.       }
  19.       _loc3_ = _loc3_ + 1;
  20.    }
  21. }
  22. function baueVorschau()
  23. {
  24.    var _loc3_ = 0;
  25.    while(_loc3_ < vorschau.zeilen)
  26.    {
  27.       var _loc1_ = 0;
  28.       while(_loc1_ < vorschau.spalten)
  29.       {
  30.          var _loc2_ = _loc3_ * vorschau.spalten + _loc1_;
  31.          this.mc_vorschau.attachMovie("mc_stein",_loc2_,_loc2_ + vorschau.tiefe,{_x:_loc1_ * stein.breite,_y:_loc3_ * stein.hoehe,feldnr:_loc2_});
  32.          _loc1_ = _loc1_ + 1;
  33.       }
  34.       _loc3_ = _loc3_ + 1;
  35.    }
  36.    this.mc_vorschau._visible = vorschau.aktiv;
  37.    if(!vorschau.aktiv)
  38.    {
  39.       this.bg_vorschau.gotoAndStop("ohneVorschau");
  40.       vorschau.zusatzPunkte = 0.5;
  41.    }
  42.    else
  43.    {
  44.       this.bg_vorschau.gotoAndStop("mitVorschau");
  45.       vorschau.zusatzPunkte = 0;
  46.    }
  47. }
  48. function vStein(vPos, vFarbe)
  49. {
  50.    this.mc_vorschau[vPos].gotoAndStop(vFarbe + 1);
  51. }
  52. function zeigeVorschau()
  53. {
  54.    stein.farbe = stein.vFarbe;
  55.    loescheVorschau();
  56.    stein.vFarbe = steinFarbe();
  57.    var _loc1_ = 0;
  58.    while(_loc1_ < 4)
  59.    {
  60.       vPos = stein.formation[stein.vFarbe * vorschau.anzahlFelder + _loc1_];
  61.       vorschau.pos[_loc1_] = vPos;
  62.       vStein(vorschau.pos[_loc1_],stein.vFarbe + 1);
  63.       _loc1_ = _loc1_ + 1;
  64.    }
  65. }
  66. function loescheVorschau()
  67. {
  68.    var _loc1_ = 0;
  69.    while(_loc1_ < vorschau.posLaenge)
  70.    {
  71.       vStein(vorschau.pos[_loc1_],0);
  72.       _loc1_ = _loc1_ + 1;
  73.    }
  74. }
  75. function steinF(pos, farbe)
  76. {
  77.    this.mc_feld[pos].gotoAndStop(farbe + 1);
  78.    spielfeld.feldFarbe[pos] = farbe;
  79. }
  80. function zeigeSteine()
  81. {
  82.    var _loc1_ = 0;
  83.    while(_loc1_ < 4)
  84.    {
  85.       stein.pos[_loc1_] = stein.formation[stein.farbe * vorschau.anzahlFelder + _loc1_ + 4 * stein.rotation];
  86.       spielfeld.pos[_loc1_] = stein.pos[_loc1_] + int(stein.pos[_loc1_] / 4) * spielfeld.feldDiff + stein.posY + stein.posX;
  87.       steinF(spielfeld.pos[_loc1_],stein.farbe + 1);
  88.       _loc1_ = _loc1_ + 1;
  89.    }
  90. }
  91. function loescheSteine()
  92. {
  93.    var _loc1_ = 0;
  94.    while(_loc1_ < vorschau.posLaenge)
  95.    {
  96.       steinF(spielfeld.pos[_loc1_],0);
  97.       spielfeld.feldFarbe[spielfeld.pos[_loc1_]] = 0;
  98.       _loc1_ = _loc1_ + 1;
  99.    }
  100. }
  101. function stopFallen()
  102. {
  103.    if(spielfeld.pos[3] > spielfeld.anzahlFelder - spielfeld.spalten - 1)
  104.    {
  105.       return true;
  106.    }
  107.    var _loc1_ = 0;
  108.    while(_loc1_ < 4)
  109.    {
  110.       if(spielfeld.feld[spielfeld.pos[_loc1_] + spielfeld.spalten] == 1)
  111.       {
  112.          return true;
  113.       }
  114.       _loc1_ = _loc1_ + 1;
  115.    }
  116. }
  117. function startPos()
  118. {
  119.    stein.posX = stein.startPosX;
  120.    stein.posY = stein.startPosY;
  121.    stein.rotation = stein.startRotation;
  122.    zeigeVorschau();
  123.    zeigeSteine();
  124.    spiel.level = spiel.zeilen < spiel.levelWechsel[spiel.level - 1] ? spiel.level : spiel.level + 1;
  125.    punkteZeigen();
  126. }
  127. function fallen()
  128. {
  129.    var _loc2_ = _root;
  130.    stein.sprungBereit = true;
  131.    var _loc3_ = stopFallen();
  132.    if(!_loc3_)
  133.    {
  134.       stein.posY += spielfeld.spalten;
  135.       loescheSteine();
  136.       zeigeSteine();
  137.    }
  138.    else
  139.    {
  140.       var _loc1_ = 0;
  141.       while(true)
  142.       {
  143.          if(_loc1_ >= 4)
  144.          {
  145.             ganzeZeile();
  146.             if(stein.zeilen == 0)
  147.             {
  148.                startPos();
  149.             }
  150.             break;
  151.          }
  152.          spielfeld.feld[spielfeld.pos[_loc1_]] = 1;
  153.          if(spielfeld.pos[_loc1_] < spielfeld.spalten * 2)
  154.          {
  155.             trace("SPIELSTOPP");
  156.             _loc2_.gotoAndStop("ende");
  157.             break;
  158.          }
  159.          _loc1_ = _loc1_ + 1;
  160.       }
  161.    }
  162. }
  163. function drehen(richtung)
  164. {
  165.    tempRotation = stein.rotation;
  166.    if(richtung == "rechts")
  167.    {
  168.       if(tempRotation < 3)
  169.       {
  170.          tempRotation++;
  171.       }
  172.       else
  173.       {
  174.          tempRotation = 0;
  175.       }
  176.    }
  177.    else if(richtung == "links")
  178.    {
  179.       if(tempRotation > 0)
  180.       {
  181.          tempRotation--;
  182.       }
  183.       else
  184.       {
  185.          tempRotation = 3;
  186.       }
  187.    }
  188.    var _loc1_ = 0;
  189.    while(true)
  190.    {
  191.       if(_loc1_ >= 4)
  192.       {
  193.          stein.rotation = tempRotation;
  194.          loescheSteine();
  195.          zeigeSteine();
  196.          break;
  197.       }
  198.       tempStein = stein.formation[stein.farbe * vorschau.anzahlFelder + _loc1_ + 4 * tempRotation];
  199.       tempPosition = tempStein + (int(tempStein / 4) * spielfeld.feldDiff + stein.posY + stein.posX);
  200.       if(tempPosition > spielfeld.anzahlFelder - spielfeld.spalten - 1)
  201.       {
  202.          break;
  203.       }
  204.       if(spielfeld.feld[tempPosition] == 1)
  205.       {
  206.          break;
  207.       }
  208.       tempAussen = tempPosition - stein.posY - int(tempStein / 4) * spielfeld.spalten;
  209.       if(tempAussen > spielfeld.spalten - 1)
  210.       {
  211.          stein.posX--;
  212.       }
  213.       else if(tempAussen < 0)
  214.       {
  215.          stein.posX = stein.posX + 1;
  216.       }
  217.       _loc1_ = _loc1_ + 1;
  218.    }
  219. }
  220. function schieben(richtung)
  221. {
  222.    if(richtung == "links")
  223.    {
  224.       var _loc1_ = 0;
  225.       while(true)
  226.       {
  227.          if(_loc1_ < 4)
  228.          {
  229.             tempPosition = stein.pos[_loc1_] + (int(stein.pos[_loc1_] / 4) * spielfeld.feldDiff + stein.posY + stein.posX - 1);
  230.             if(spielfeld.feld[tempPosition] != 1)
  231.             {
  232.                if(spielfeld.pos[_loc1_] - stein.posY - int(stein.pos[_loc1_] / 4) * spielfeld.spalten > 0)
  233.                {
  234.                   continue;
  235.                }
  236.             }
  237.          }
  238.          else
  239.          {
  240.             stein.posX--;
  241.             loescheSteine();
  242.             zeigeSteine();
  243.          }
  244.       }
  245.    }
  246.    else if(richtung == "rechts")
  247.    {
  248.       _loc1_ = 0;
  249.       while(true)
  250.       {
  251.          if(_loc1_ >= 4)
  252.          {
  253.             stein.posX = stein.posX + 1;
  254.             loescheSteine();
  255.             zeigeSteine();
  256.             break;
  257.          }
  258.          tempPosition = stein.pos[_loc1_] + (int(stein.pos[_loc1_] / 4) * spielfeld.feldDiff + stein.posY + stein.posX + 1);
  259.          if(spielfeld.feld[tempPosition] == 1)
  260.          {
  261.             break;
  262.          }
  263.          if(spielfeld.pos[_loc1_] - stein.posY - int(stein.pos[_loc1_] / 4) * spielfeld.spalten >= spielfeld.spalten - 1)
  264.          {
  265.             break;
  266.          }
  267.          _loc1_ = _loc1_ + 1;
  268.       }
  269.    }
  270. }
  271. function sprungZeile()
  272. {
  273.    i = stein.posY;
  274.    while(i < spielfeld.anzahlFelder)
  275.    {
  276.       var _loc3_ = i + spielfeld.spalten;
  277.       var _loc2_ = _loc3_ - stein.posY;
  278.       var _loc1_ = 0;
  279.       while(_loc1_ < 4)
  280.       {
  281.          if(spielfeld.feld[spielfeld.pos[_loc1_] + _loc2_] == 1)
  282.          {
  283.             return i;
  284.          }
  285.          if(spielfeld.pos[_loc1_] + _loc2_ >= spielfeld.anzahlFelder)
  286.          {
  287.             return i;
  288.          }
  289.          _loc1_ = _loc1_ + 1;
  290.       }
  291.       i += spielfeld.spalten;
  292.    }
  293. }
  294. function sprung()
  295. {
  296.    spielStop();
  297.    stein.sprungBereit = false;
  298.    stein.sprungZeile = sprungZeile();
  299.    var _loc1_ = (stein.sprungZeile - stein.posY) * spiel.level / 10 + spiel.punktDiff;
  300.    _loc1_ = Math.floor(_loc1_ + _loc1_ * vorschau.zusatzPunkte);
  301.    spiel.punkte += _loc1_;
  302.    stein.posY = stein.sprungZeile;
  303.    stein.sprungZeile = 0;
  304.    loescheSteine();
  305.    zeigeSteine();
  306.    ganzeZeile();
  307.    if(stein.zeilen == 0)
  308.    {
  309.       spielen();
  310.    }
  311. }
  312. function ganzeZeile()
  313. {
  314.    stein.zeilen = 0;
  315.    var i = 0;
  316.    while(i < spielfeld.zeilen)
  317.    {
  318.       var belegteFelder = 0;
  319.       var _loc2_ = 0;
  320.       while(_loc2_ < spielfeld.spalten)
  321.       {
  322.          var _loc3_ = i * spielfeld.spalten + _loc2_;
  323.          belegteFelder += spielfeld.feld[_loc3_];
  324.          if(belegteFelder == spielfeld.spalten)
  325.          {
  326.             spielStop();
  327.             stein.zeilen = stein.zeilen + 1;
  328.             var _loc1_ = 0;
  329.             while(_loc1_ < spielfeld.spalten)
  330.             {
  331.                _loc3_ = i * spielfeld.spalten + _loc1_;
  332.                this.mc_feld[_loc3_].gotoAndStop("treffer");
  333.                _loc1_ = _loc1_ + 1;
  334.             }
  335.          }
  336.          _loc2_ = _loc2_ + 1;
  337.       }
  338.       i++;
  339.    }
  340.    spiel.zeilen += stein.zeilen;
  341. }
  342. function rueckeSteine()
  343. {
  344.    for(var steinName in stein.treffer)
  345.    {
  346.       var _loc1_ = stein.treffer[steinName];
  347.       while(_loc1_ >= 0)
  348.       {
  349.          var _loc2_ = spielfeld.feldFarbe[_loc1_ - spielfeld.spalten];
  350.          steinF(_loc1_,_loc2_);
  351.          if(_loc2_ > 0)
  352.          {
  353.             spielfeld.feld[_loc1_] = 1;
  354.             spielfeld.feldFarbe[_loc1_] = _loc2_;
  355.          }
  356.          else
  357.          {
  358.             spielfeld.feld[_loc1_] = 0;
  359.             spielfeld.feldFarbe[_loc1_] = 0;
  360.          }
  361.          steinF(_loc1_ - spielfeld.spalten,0);
  362.          spielfeld.feld[_loc1_ - spielfeld] = 0;
  363.          _loc1_ -= spielfeld.spalten;
  364.       }
  365.       if(steinName == 0)
  366.       {
  367.          stein.treffer.splice(0,stein.treffer.length);
  368.          var _loc3_ = spiel.level * spiel.zeilenPunkte[stein.zeilen - 1];
  369.          _loc3_ += _loc3_ * vorschau.zusatzPunkte;
  370.          spiel.punkte += _loc3_;
  371.          stein.zeilen = 0;
  372.          punkteZeigen();
  373.          startPos();
  374.          spielen();
  375.       }
  376.    }
  377. }
  378. function geschwindigkeit()
  379. {
  380.    return spiel.geschwindigkeit[spiel.level - 1];
  381. }
  382. function punkteZeigen()
  383. {
  384.    var _loc1_ = this;
  385.    _loc1_.punkte = spiel.punkte;
  386.    _loc1_.level = spiel.level;
  387.    _loc1_.zeilen = spiel.zeilen;
  388. }
  389. function spielen()
  390. {
  391.    stein.sprungBereit = true;
  392.    interval = setInterval(fallen,geschwindigkeit());
  393. }
  394. function spielStop()
  395. {
  396.    stein.sprungBereit = false;
  397.    clearInterval(interval);
  398. }
  399. function spielPause()
  400. {
  401.    spielStop();
  402.    spiel.pause = true;
  403.    _root.mc_feld.attachMovie("mc_abdecker","abd_pause",1000);
  404. }
  405. function spielWeiter()
  406. {
  407.    spiel.pause = false;
  408.    removeMovieClip(_root.mc_feld.abd_pause);
  409.    spielen();
  410. }
  411. function spielAbbrechen()
  412. {
  413.    spielStop();
  414.    removeMovieClip(mc_feld);
  415.    removeMovieClip(mc_vorschau);
  416. }
  417. spiel = {};
  418. spiel.punkte = 0;
  419. spiel.zeilen = 0;
  420. spiel.punktDiff = 2;
  421. spiel.level = 1;
  422. spiel.levelWechsel = [20,40,60,80,10000];
  423. spiel.zeilenPunkte = [20,50,150,600];
  424. spiel.geschwindigkeit = [500,450,350,250,150];
  425. vorschau = {};
  426. vorschau.posX = 370;
  427. vorschau.posY = 90;
  428. vorschau.zeilen = 4;
  429. vorschau.spalten = 4;
  430. vorschau.tiefe = 400;
  431. vorschau.anzahlFelder = vorschau.zeilen * vorschau.spalten;
  432. vorschau.pos = [0,0,0,0];
  433. vorschau.posLaenge = vorschau.pos.length;
  434. vorschau.aktiv = true;
  435. vorschau.zusatzPunkte = 0;
  436. spielfeld = {};
  437. spielfeld.posX = 156;
  438. spielfeld.posY = 90;
  439. spielfeld.zeilen = 20;
  440. spielfeld.spalten = 10;
  441. spielfeld.tiefe = 100;
  442. spielfeld.feld = new Array();
  443. spielfeld.feldFarbe = new Array();
  444. spielfeld.anzahlFelder = spielfeld.zeilen * spielfeld.spalten;
  445. spielfeld.feldDiff = spielfeld.spalten - vorschau.spalten;
  446. spielfeld.pos = [0,0,0,0];
  447. spielfeld.posLaenge = spielfeld.pos.length;
  448. stein = {};
  449. stein.breite = 15;
  450. stein.hoehe = 15;
  451. stein.startPosX = 0;
  452. stein.startPosY = -10;
  453. stein.startRotation = 0;
  454. stein.fallen = true;
  455. stein.treffer = new Array();
  456. stein.pos = [0,0,0,0];
  457. stein.formation = [5,6,9,10,5,6,9,10,5,6,9,10,5,6,9,10,4,5,6,9,1,4,5,9,1,4,5,6,1,5,6,9,4,5,9,10,1,4,5,8,4,5,9,10,1,4,5,8,5,6,8,9,0,4,5,9,5,6,8,9,0,4,5,9,4,5,6,8,0,1,5,9,2,4,5,6,1,5,9,10,4,5,6,10,1,5,8,9,0,4,5,6,1,2,5,9,4,5,6,7,1,5,9,13,4,5,6,7,1,5,9,13];
  458. stein.rotation = stein.startRotation;
  459. stein.posY = stein.startPosY;
  460. stein.posX = stein.startPosX;
  461. stein.zeilen = 0;
  462. stein.intervalSchieben = 0;
  463. stein.intervalRechts = 0;
  464. stein.maxSchieben = 2;
  465. stein.intervalDrehen = 0;
  466. stein.maxDrehen = 4;
  467. stein.intervalRunter = 0;
  468. stein.maxRunter = 1;
  469. stein.sprungBereit = true;
  470. stein.intervalSprung = 0;
  471. this.createEmptyMovieClip("mc_feld",0);
  472. with(mc_feld)
  473. {
  474.    _x = spielfeld.posX;
  475.    _y = spielfeld.posY;
  476. }
  477. this.createEmptyMovieClip("mc_vorschau",1);
  478. with(mc_vorschau)
  479. {
  480.    _x = vorschau.posX;
  481.    _y = vorschau.posY;
  482. }
  483. this.b_impressum.onPress = function()
  484. {
  485.    this.onPressEvent();
  486.    _root.gotoAndStop("impressum");
  487.    spielAbbrechen();
  488. };
  489. this.b_hilfe.onPress = function()
  490. {
  491.    this.onPressEvent();
  492.    _root.gotoAndStop("hilfe");
  493.    spielAbbrechen();
  494. };
  495. this.b_start.onPress = function()
  496. {
  497.    this.onPressEvent();
  498.    _root.gotoAndStop("start");
  499. };
  500. this.b_spielen.onPress = function()
  501. {
  502.    this.onPressEvent();
  503.    _root.gotoAndStop("spielen");
  504. };
  505. tastenEvent.addListener(spielTasten);
  506. Key.addListener(tasten);
  507. stop();
  508.