লেওনহার্ড গোলকধাঁধা পছন্দ করে

Question

পটভূমি

আমার ছেলে লিওনহার্ড (4 বছর বয়সী) গোলকধাঁধা পছন্দ করে। তিনি কোথা থেকে গোলকধাঁধা জানেন তা আমি জানি না, তবে সেগুলি এঁকে দেয় এবং তারা কীভাবে কাজ করে তা বেশ ভালভাবেই জানেন:

সম্প্রতি, তিনি তাঁর চিত্রগুলি থেকে একটি গেম তৈরি শুরু করেছিলেন। এগুলি তাঁর নিয়ম:

• একটি কালো বর্গক্ষেত্র প্রারম্ভিক বিন্দু নির্দেশ করে।
• একটি হুক গোলকধাঁধাঁটির প্রস্থানটি বোঝায় (আপনি যেখানে টানেন সেখান থেকে)।
• আপনি মুকুট সংগ্রহ করতে পারেন।
• আপনি সোনার গালি (গোল জিনিস) সংগ্রহ করতে পারেন।
• আপনি সামনের দিকে এবং পিছনে যেতে পারেন তবে এর চেয়ে বেশি নয়।
• তীরগুলি আপনাকে প্রস্থান করতে গাইড করতে পারে। (যদি তিনি আমার সমাধান করার জন্য কোনও গোলকধাঁধা আঁকেন তবে তারা প্রায়শই বিভ্রান্তিকর হয়)।

টীকাগুলি সংস্করণ:

• নীল: প্রারম্ভিক বিন্দু
• কমলা: মুকুট
• হলুদ: সোনার নগেট সহ অঞ্চল
• সবুজ: হুক (প্রস্থান)
• গোলাপী: তীর (বেশিরভাগ বিভ্রান্তিমূলক)

কাজটি

সম্ভবত আপনি জানেন, 4 বছর বয়সে বাচ্চারা শূকর-পাইগুলি বলতে শুরু করে এবং কখনও কখনও সে তার নিজের নিয়মগুলি অনুসরণ করে না, বিশেষত যদি সে জানতে পারে যে সে আর ধাঁধার শেষে পৌঁছতে পারে না।

আপনি এখানে খেলতে এসেছেন: যেহেতু আমি যাইহোক বাচ্চাদের জন্য গেমস খুঁজছি , আপনি তার ধারণাটিকে এমন একটি খেলায় পরিণত করেছেন যেখানে প্রতারণা সম্ভব নয়।

ঠিক আছে, আমাদের আরও কিছু সংজ্ঞা দরকার যা আমি বলব:

• খেলার ক্ষেত্রটি সমান আকারের স্কোয়ারগুলির একটি n* mআয়তক্ষেত্র।
• একটি স্কোয়ারে 0 থেকে 4 দেয়াল থাকতে পারে, প্রতিটি পাশে একটি করে দেয়াল থাকতে পারে।
• একটি মুকুট 50 পয়েন্ট মূল্যবান।
• একটি সোনার ন্যাগেটের মূল্য 20 পয়েন্ট।
• এমন স্কোয়ারে হাঁটা যা ইতিমধ্যে হেঁটে গেছে 1 পয়েন্টটি বিয়োগ করে।
• স্কয়ারগুলি চিহ্নিত করা যায় যাতে খেলোয়াড় কতবার এটি চালিয়ে যায় তা চিহ্নিত করার জন্য (0, 1 বা 2 বার)
• প্লেয়ারটি যদি কোনও দেয়াল না থাকে তবে 4 দিক দিয়ে হাঁটতে পারে।
• ইনপুট ডিভাইস যে কোনও কিছু হতে পারে। কীবোর্ড সমর্থন বিবেচনা করুন।
• গোলকধাঁধা অবশ্যই দ্রবণযোগ্য হতে হবে। অর্থাৎ প্রারম্ভিক বিন্দু থেকে হুক পৌঁছানো অবশ্যই সম্ভব এবং সমস্ত মূল্যবান জিনিস সংগ্রহ করা অবশ্যই সম্ভব (এমনকি এটি যদি সর্বোচ্চ সম্ভাব্য স্কোরের ফলাফল নাও দেয়)।
• খেলোয়াড় আটকে গেলে, খেলাটি শেষ হয়।
• খেলোয়াড় বোর্ড থেকে পড়ে মারা যাবে না। আপনি সম্পূর্ণ ধাঁধাটির চারপাশে একটি প্রাচীর স্থাপন করতে পারেন বা আপনার পছন্দ মতো প্রান্তগুলি মোড়ানো করতে পারেন।
• প্রোগ্রামটি ইনপুট হিসাবে একটি শব্দ (0-65535) লাগে। এটি এলোমেলো সংখ্যা জেনারেটরের জন্য বীজ। একই বীজের সাথে প্রোগ্রামটি কল করার পরে একই গোলকধাঁধার ফলাফল হয়।

বোনাস:

• সংগ্রহ করা যায় এমন সর্বোচ্চ পয়েন্ট গণনা করুন। বিবেচনা করুন যে -1 পয়েন্টের কারণে সমস্ত আইটেম সংগ্রহ না করা ভাল।
• সেরা সমাধান (সর্বাধিক পয়েন্ট পাওয়ার সংক্ষিপ্ততম উপায়) দেখান

নিয়ম

এটি একটি জনপ্রিয়তা প্রতিযোগিতা, যেহেতু আমি কোডটি পড়তে এবং বুঝতে এবং সম্ভবত আমার ছেলের নতুন ধারণাগুলির সাথে মানিয়ে নিতে সক্ষম হতে চাই। দুঃখিত, কোড গল্ফাররা, আপনি গল্ফিংয়ের পক্ষে আরও উপযুক্ত বিধি সহ এই প্রশ্নের একটি অনুলিপি তৈরি করতে চান, যেমন সমস্ত অক্ষর সংজ্ঞায়িত করে একটি কনসোল সংস্করণ।

3 শে মে সর্বাধিক জনপ্রিয় খেলাটি গ্রহণযোগ্য উত্তরে পরিণত হবে। এবং, আরে, কেন এটি কোনও অ্যাপ স্টোরে প্রকাশ করবেন না?

Comments

আমি মনে করি যেন কোনও প্রোগ্রামিং বনাম কোনও শিল্প প্রতিযোগিতা বেশি হওয়ার কারণে এটি আগুনের কবলে পড়তে পারে। যেহেতু এই সমস্ত গেমগুলির প্রায় একইরকম আচরণ করা উচিত, তবে কী কারণে দেখতে একে অপরের পক্ষে ভোট দিতে হবে? এই ধাঁধা গেমটি তৈরিতে তেমন সম্ভাব্য সৃজনশীলতা নেই বলে মনে হয়। এটি বলেছিল, আমি আরও গল্ফার, তাই আমি আরও বেশি ঘন ঘন পপ-কনসে অংশ নেওয়া লোকদের যদি সিদ্ধান্ত হয় যে এটি এই বিষয়টিতে রয়েছে কিনা তা সিদ্ধান্ত নিতে দেব।

— FryAmTheEggman

এই চ্যালেঞ্জের দুটি পৃথক অংশ রয়েছে: একটি হ'ল গোলকধাঁধা নকশা (তবে অ্যালগোরিদমিকভাবে একটি সন্তোষজনক গেম গোলকধাঁধা উত্পাদন করা কঠিন) এবং অন্যটি গেম ইঞ্জিন (যা বরং সহজ)। আমি মনে করি আপনি যদি চ্যালেঞ্জটি গেম ইঞ্জিনের (এবং এটিকে একটি কোড গল্ফ হিসাবে সীমাবদ্ধ করে থাকেন) সীমাবদ্ধ রাখেন তবে এটি আরও ভাল হবে আপনার প্রশ্নের কিছু নমুনা গোলকধাঁধা (টেক্সট ফাইল থেকে ইনপুট হিসাবে নেওয়া) আপনার পোস্টের প্রয়োজন হবে (সম্ভবত আপনার সাথে ডিজাইন করা ছেলের সহায়তা।)

— স্তর নদী সেন্ট

সম্পর্কিত (এবং সম্ভবত গোলকধাঁধা নকশার অংশের আংশিক সদৃশ) কোডগলফ.স্ট্যাকেক্সেঞ্জারওয়েজ

— স্তর নদী সেন্ট

আমি মনে করি এটি একটি দুর্দান্ত চ্যালেঞ্জ। এটি সমাধান করতে বেশ কয়েকটি সমস্যা এবং সৃজনশীলতার জন্য জায়গা রয়েছে। এর মতো আরও চ্যালেঞ্জ দয়া করে +1 করুন। [একটি সমাধান

— লজিক নাইট

আমাদের কি "তীর" তৈরি করতে হবে? তারা কি খেলোয়াড়কে অন্যভাবে পার করতে দেয়?

— TheNumberOne

Answer 1

জাভাস্ক্রিপ্ট

কাজ চলছে. দুর্ভাগ্যক্রমে গোলকধাঁটি সর্বদা দ্রবণযোগ্য হয় না - ব্যাক-ফরওয়ার্ডের সীমাটি আসল প্রতিবন্ধকতা।

1 কসমেটিক
সম্পাদনা 2 আরও ভাল গেমপ্লে সম্পাদনা করুন , তবে বড় সমস্যাটি এখনও আছে

var rows, columns, rowOfs, maze, plPos, points, playing

$('#BNEW').on('click', function() {
    NewMaze();
});
$('#BREP').on('click', function() {
    Start();
});

$(document).on('keydown', function(e) {
    var ok, move, pxy, mz, $td
    switch (e.which)
    {
    case 37:
        (move = -1, ok = maze[plPos+move] < 9 && maze[plPos+move*2] < 9);
        break;
    case 39:
        (move = 1, ok = maze[plPos+move] < 9 && maze[plPos+move*2] < 9);
        break;
    case 38: 
        (move = -rowOfs, ok = maze[plPos+move] < 9 && maze[plPos+move*2] < 9);
        break;
    case 40: 
        (move = rowOfs, ok = maze[plPos+move] < 9 && maze[plPos+move*2] < 9);
        break;
    }
    if (playing && ok)
    {
        pxy = getXY(plPos)
        mz = maze[plPos] < 8 ? 8 : 9;
        $td = $('#Field table tr').eq(pxy.y).find('td').eq(pxy.x)
        $td.addClass("m"+mz);
        maze[plPos] = mz;
        maze[plPos+move] = mz;
        plPos += move*2;
        mz = maze[plPos];
        PTS.value = mz==7 ? points += 20 : mz==6 ? points += 50 : mz == 8 ? points -= 1 : points;
        
        pxy = getXY(plPos)
        $td = $('#Field table tr').eq(pxy.y).find('td').eq(pxy.x)
        $td.removeClass("m6 m7")
        $('#Player').finish().animate(playerCss(pxy.x,pxy.y));
        CheckEndGame();
    }
    return !move
});

function CheckEndGame()
{
  var msg = ''
  if (maze[plPos] == 5)
  {
      msg = "Maze completed!";
  }
  else if (maze[plPos+1]==9 && maze[plPos-1]==9
        && maze[plPos+rowOfs]==9 && maze[plPos-rowOfs]==9)
  {
      msg = "You are stuck, try again!";
  }
  if (msg) {
    $("#Msg").text(msg).show();
    playing=false
  }
}

function seed(s) {
    return function() {
        s = Math.sin(s) * 10000; return s - Math.floor(s);
    };
};

function Build()
{
    var i
    var Fill = function(p)
    {
        var d=[rowOfs,-rowOfs,1,-1], i, s, l
        maze[p] = 1
        while(d[0])
        {
            i = random()*d.length|0
            s = d[i]
            if (s != (l=d.pop())) d[i]=l
            if (maze[p+s+s]>8) {
                maze[p+s] = 1, Fill(p+s+s)
            }
        }
    }
    rowOfs = (columns + 1) * 2
    maze = Array(rowOfs * (rows*2+1))
    for (i=0; i < maze.length; i++)
        maze[i] = i % rowOfs? 9 : 0
    Fill(rowOfs+2)
}

function NewMaze()
{
    SEED.value = Math.random()*65536 | 0
    Start()
}
    
function Start()
{
    var sd = SEED.value || 1
    columns = COLS.value |0 || 18
    rows = ROWS.value | 0 || 12
    COLS.value = columns
    ROWS.value = rows
    random = seed(sd)
    PTS.value = points = 0
    $("#Msg").hide();

    Build()
    
    plx = random()*columns|0;
    ply = random()*rows|0;
    setPlayer(plx,ply);
    plPos = getPos(plx,ply);
    BlockTriples(plPos);
    AddItems(plPos);
    Draw();
    playing = true;
  
}

function AddItems(p)
{
    var d=[rowOfs,-rowOfs,1,-1]
    var cells=[]
    // scan all reachable cells and calc distance from start
    var Go = function(p,l)
    {
        var i,t,mark,r
        ++l
        cells.push([p,l])
            
        maze[p] = 8;
        for(i=0; d[i]; i++)
        {
            t = d[i]
            if (maze[p+t]<2 && maze[p+t+t]<2) 
            {
                Go(p+t+t, l)
            }
        }
        maze[p] = 0;
    } 
    Go(p,0)
    cells.sort(function(a,b){return a[1]-b[1]})
    cells=cells.slice(10) // cut the shortest distances 
    r = random()*10|0; //exit
    r = cells.length-r-1
    maze[cells[r][0]] = 5;
    console.log(r)
    cells = cells.slice(0,r)
    var ncr = rows, nnu = columns
    for(i = ncr+nnu; i; i--) 
    {
        r = random()*cells.length|0
        maze[cells[r][0]] = (i > ncr ? 7 : 6);
        cells[r] = cells.pop();
    }
    
    
}

function BlockTriples(p)
{
    var d=[rowOfs,-rowOfs,1,-1]
    var Go = function(p)
    {
        var i,t,size=[0,0,0,0],s=1,nw=0,min,minp
        maze[p] = 8
        for(i=0; d[i]; i++)
        {
            t = d[i]
            if (maze[p+t]<9 && maze[p+t+t]<8) 
            {
                ++nw
                s += size[i] = Go(p+t+t)
            }
        }
        if (nw > 2) // triple way, block the smallest
        {
            for(i=0,min=1e6; d[i]; i++)
                size[i] && size[i] < min && (min = size[minp = i])
            maze[p + d[minp]] = 5;
        }
        maze[p]=0
        return s
    } 
    Go(p)
}
    
function Draw()
{    
    var q=[], i, x, y;
    for(i = rowOfs+2, y = 0; y < rows; y++)
    {
        q.push('<tr>')
        for (x = 0; x < columns; i += 2, x++)
        {
            tcl = 'm'+(maze[i]|0)       
            maze[i-1]>8 && (tcl += ' wl')
            maze[i+1]>8 && (tcl += ' wr')
            maze[i-rowOfs]>8 && (tcl += ' wu')
            maze[i+rowOfs]>8 && (tcl += ' wb')
            q.push('<td class="'+tcl+'"></td>')
        }
        q.push('</tr>')
        i += rowOfs+2
    }
    $("#TOUT").html(q.join(''));
    $("#Field").show();
}

function setPlayer(posx, posy)
{
    $('#Player').css(playerCss(posx, posy));
}    

function getXY(pos)
{
    return { x: (plPos % rowOfs)/2-1, y: plPos / rowOfs / 2 | 0}
}

function getPos(x, y)
{
   return (x+y*rowOfs)*2 + rowOfs+2;
}

function playerCss(posx, posy)
{
    return{ left: 6+posx*21, top: posy*21+2};
}

input { width: 3em; margin-right:1em }
table { 
  border: 2px solid #000; 
  border-collapse: collapse;
  font-size: 8px }
#Field { 
  margin: 10px; 
  position: relative;
  display: none;
}
td { 
    width: 19px; height: 19px; 
    padding: 0; margin: 0; 
    text-align: center;
}
td.wl { border-left: 2px solid #444; background: #fff }
td.wr { border-right: 2px solid #444; background: #fff }
td.wt { border-top: 2px solid #444;; background: #fff }
td.wb { border-bottom: 2px solid #444; background: #fff }
td.m7 { background: #ffd url(http://i.stack.imgur.com/QUInh.png) -21px 0}
td.m6 { background: #efe url(http://i.stack.imgur.com/QUInh.png) -1px 0}
td.m5 { background: #ddf url(http://i.stack.imgur.com/QUInh.png) -40px 0}
td.m8 { background: #eed }
td.m9 { background: #f55 }
#Player { position: absolute; top:0; left:0; color: #007; background: #fcb; font-size:12px }
#Msg { color: red; font-size:40px; display:none;  }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
ID:<input id=SEED>
Rows:<input id=ROWS>
Columns:<input id=COLS>
<button id=BNEW>New</button>
<button id=BREP>Replay</button>
<div id=Msg></div>
<div id=Field>
<table id=TOUT border=0 cellspacing=0 cellpadding=0>
</table>
<span id=Player>⛄</span>    
</div>
Score: <input readonly id=PTS>

Comments

ভাল হয়েছে, চিত্তাকর্ষক। You আপনি কীভাবে গোলকধাঁধা তৈরি করেন তার 'যুক্তি' আমি পাই না। অংশটি কীভাবে কাজ করে?

— কাজিনকোকেইন

@CousinCocaine ফাংশন বিল্ড ব্যবহার একটি recursive ভরাট, এটা আরো 'সর্বোত্তম' উপায় কেবল সংযুক্ত ধাঁধা নির্মাণ করতে এর - দেখুন en.wikipedia.org/wiki/Maze_generation_algorithm

— edc65

আমার ছেলে এটি পছন্দ করে। যদিও তিনি আমাকে আরও বড় আকারের ম্যাজগুলি মুদ্রণ করতে চান, তিনি অনলাইনে আরও ছোট খেলেন। নিয়ম অনুসারে, 3 শে মে আপনার উত্তরটি সেরা ছিল, তাই এখনই আমি এটি গ্রহণ করেছি। যেহেতু এটিও একমাত্র উত্তর, আপনি অনুগ্রহ পান। ভাল, এটি আশ্চর্যজনক।

— টমাস ভেলার

আপনাকে অনেক ধন্যবাদ, খুশী যে আপনার ছেলে এটি পছন্দ করে। এখন বিড বাড়ানোর সময় এসেছে।

— edc65

Answer 2

জাভা

আমি গল্ফস্ক্রিপ্ট বা সিজেম সম্পর্কে কখনও অভিযোগ করি নি, তবে যাইহোক আপনার জন্য এখানে জাভা উত্তর রয়েছে। এটি ছিল সত্যিই উপভোগযোগ্য একটি চ্যালেঞ্জ। ;)

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.geom.Ellipse2D;
import java.util.*;
import javax.swing.*;

public class MazeMaker {
    int row, col, exitRow, exitCol, numCells, score, array[][];
    final int SQWIDTH = 20;
    boolean gameOver = true;
    Ellipse2D.Double ellipse;
    JFrame frame;
    JPanel mazePanel;
    JLabel scoreLabel;

    public MazeMaker() {
        frame = new JFrame("Maze");
        frame.setLayout(new BorderLayout());
        JPanel topPanel = createTopPanel();
        frame.add(topPanel,BorderLayout.NORTH);

        createMazePanel();
        frame.add(new JScrollPane(mazePanel),BorderLayout.CENTER);

        setKeyActions();

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);
    }

    private void constructArray(int seed, int rows, int cols) {
        array = new int[rows*2-1][cols*2-1];
        for (int[] a : array)
            Arrays.fill(a,-1);
        numCells = (array.length / 2 + 1) * (array[0].length / 2 + 1);
        Random rand = new Random(seed);
        int row = rand.nextInt(array.length / 2 + 1) * 2;
        int col = rand.nextInt(array[0].length / 2 + 1) * 2;
        array[row][col] = 0;
        boolean first = true, a = false, exitFound = false;

        while (true) {
            if (first) {
                int direction = rand.nextInt(4);
                if (direction == 0 && row != 0) {
                    array[row-1][col] = 0;
                    array[row-2][col] = 0;
                    row -= 2;
                    first = false;
                }
                else if (direction == 1 && col != array[0].length - 1) {
                    array[row][col+1] = 0;
                    array[row][col+2] = 0;
                    col += 2;
                    first = false;
                }
                else if (direction == 2 && row != array.length - 1) {
                    array[row+1][col] = 0;
                    array[row+2][col] = 0;
                    row += 2;
                    first = false;
                }
                else if (direction == 3 && col != 0) {
                    array[row][col-1] = 0;
                    array[row][col-2] = 0;
                    col -= 2;
                    first = false;
                }
            }
            else {
                int availableCells = 0;
                boolean up = false, down = false, left = false, right = false;
                if (row != 0 && array[row-2][col] == -1) {
                    availableCells++;
                    up = true;
                }

                if (col != array[0].length-1 && array[row][col+2] == -1) {
                    availableCells++;
                    right = true;
                }

                if (row != array.length-1 && array[row+2][col] == -1) {
                    availableCells++;
                    down = true;
                }

                if (col != 0 && array[row][col-2] == -1) {
                    availableCells++;
                    left = true;
                }

                if (availableCells != 0) {
                    a = true;
                    while (true) {
                        boolean[] b = {up,right,down,left};
                        int i = rand.nextInt(4);
                        if (b[i]) {
                            if (i == 0) {
                                array[row-1][col] = 0;
                                array[row-2][col] = 0;
                                row -= 2;
                            }
                            else if (i == 1) {
                                array[row][col+1] = 0;
                                array[row][col+2] = 0;
                                col += 2;
                            }
                            else if (i == 2) {
                                array[row+1][col] = 0;
                                array[row+2][col] = 0;
                                row += 2;
                            }
                            else if (i == 3) {
                                array[row][col-1] = 0;
                                array[row][col-2] = 0;
                                col -= 2;
                            }
                            break;
                        }
                    }
                }
                else {
                    array[row][col] = 1;
                    if (!exitFound && a) {
                        if (new Random().nextInt(5) == 0) {
                            exitFound = true;
                            exitRow = row;
                            exitCol = col;
                        }
                    }
                    a = false;
                    if (row != 0 && array[row-1][col] == 0 && (array[row-2][col] == 0 || array[row-2][col] == 1)) {
                        array[row-1][col] = 1;
                        array[row-2][col] = 1;
                        row -= 2;
                    }
                    else if (col != array[0].length-1 && array[row][col+1] == 0 && (array[row][col+2] == 0 || array[row][col+2] == 1)) {
                        array[row][col+1] = 1;
                        array[row][col+2] = 1;
                        col += 2;
                    }
                    else if (row != array.length-1 && array[row+1][col] == 0 && (array[row+2][col] == 0 || array[row+2][col] == 1)) {
                        array[row+1][col] = 1;
                        array[row+2][col] = 1;
                        row += 2;
                    }
                    else if (col != 0 && array[row][col-1] == 0 && (array[row][col-2] == 0 || array[row][col-2] == 1)) {
                        array[row][col-1] = 1;
                        array[row][col-2] = 1;
                        col -= 2;
                    }
                }
                if (checkDone()) {
                    if (!exitFound) {
                        exitRow = row;
                        exitCol = col;
                    }
                    break;
                }
            }
        }
    }

    private boolean checkDone() {
        int count = 0;
        for (int k = 0; k < array.length; k+=2) {
            for (int l = 0; l < array[0].length; l+=2) {
                if (array[k][l] == 0 || array[k][l] == 1)
                    count++;
            }
        }
        return count == numCells;
    }

    private JPanel createTopPanel() {
        GridBagLayout l = new GridBagLayout();
        GridBagConstraints c = new GridBagConstraints();
        c.fill = GridBagConstraints.BOTH;

        JPanel panel = new JPanel(l);
        JLabel inputLabel = new JLabel("ID:");
        c.gridwidth = 1;
        l.setConstraints(inputLabel,c);
        panel.add(inputLabel);

        JTextField inputField = new JTextField(5);
        l.setConstraints(inputField,c);
        panel.add(inputField);

        JLabel rowLabel = new JLabel("Rows:");
        l.setConstraints(rowLabel,c);
        panel.add(rowLabel);

        JTextField rowField = new JTextField(3);
        l.setConstraints(rowField,c);
        panel.add(rowField);

        JLabel colLabel = new JLabel("Columns:");
        l.setConstraints(colLabel,c);
        panel.add(colLabel);

        JTextField colField = new JTextField(3);
        l.setConstraints(colField,c);
        panel.add(colField);

        JButton applyButton = new JButton("Apply");
        applyButton.addActionListener(ev -> {
            try {
                int seed = Integer.parseInt(inputField.getText()),
                    rows = Integer.parseInt(rowField.getText()),
                    cols = Integer.parseInt(colField.getText());
                if (seed >= 0 && rows >= 3 && cols >= 3) {
                    gameOver = false;
                    scoreLabel.setText("Score: " + (score = 0));
                    constructArray(seed,rows,cols);
                    row = (int) (Math.random() * (array.length / 2 + 1)) * 2;
                    col = (int) (Math.random() * (array[0].length / 2 + 1)) * 2;
                    frame.setSize((1+SQWIDTH * array[0].length)/2 > 750 ? (1+SQWIDTH * array[0].length)/2 : 750,
                            75+(1+SQWIDTH * array.length)/2);
                    mazePanel.setPreferredSize(new Dimension(
                            (1+SQWIDTH * array[0].length)/2 > 750 ? (1+SQWIDTH * array[0].length)/2 - 15 : 750,
                            15+(1+SQWIDTH * array.length)/2));
                    ellipse = new Ellipse2D.Double(col*SQWIDTH/2+3,row*SQWIDTH/2+3,10,10);
                    setItems();
                    mazePanel.repaint();
                }
            } catch (NumberFormatException ignore) {}
        });
        l.setConstraints(applyButton,c);
        panel.add(applyButton);

        scoreLabel = new JLabel("Score: ");
        c.gridwidth = GridBagConstraints.REMAINDER;
        l.setConstraints(scoreLabel,c);
        panel.add(scoreLabel);

        return panel;
    }

    private void createMazePanel() {
        mazePanel = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                int x = 0, y = 0;
                if (!gameOver) {
                    for (int k = 0; k < array.length; k+=2) {
                        for (int l = 0; l < array[0].length; l+=2) {
                            int n = array[k][l];
                            if (n == 0 || n == 1 || n == 4 || n == 5 || n == 6)
                                g.setColor(Color.white);
                            else if (n == 2)
                                g.setColor(Color.green);
                            else if (n == 3)
                                g.setColor(Color.red);
                            g.fillRect(x, y, SQWIDTH, SQWIDTH);
                            if (n == 4) {
                                g.setColor(new Color(245,209,34));
                                g.fillOval(x+3, y+3, 10, 10);
                            }
                            else if (n == 5) {
                                g.setColor(new Color(255,223,55));
                                g.fillPolygon(new int[]{x,x+3,x+8,x+13,x+16,x+14,x+2},new int[]{y+2,y+6,y+2,y+6,y+2,y+16,y+16},7);
                                g.setColor(new Color(12,234,44));
                                g.fillOval(x+7,y+6,4,7);
                            }
                            else if (n == 6) {
                                Graphics2D g2 = (Graphics2D) g.create();
                                g2.setStroke(new BasicStroke(2,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
                                g2.setColor(new Color(108,225,119));
                                g2.drawOval(x+5, y+1, 8, 8);
                                g2.drawLine(x+5, y+3, x+5, y+11);
                                g2.drawArc(x+5, y+8, 7, 7, 180, 180);
                            }
                            g.setColor(Color.black);
                            if (k != array.length-1 && array[k+1][l] == -1)
                                g.fillRect(x-3, y+SQWIDTH-3, SQWIDTH+3, 3);
                            if (l != array[0].length-1 && array[k][l+1] == -1)
                                g.fillRect(x+SQWIDTH-3,y,3,SQWIDTH);
                            x += SQWIDTH;
                        }
                        x = 0;
                        y += SQWIDTH;
                    }
                    g.setColor(Color.red);
                    ((Graphics2D) g).fill(ellipse);
                }
            }
        };
    }

    private void setKeyActions() {
        InputMap im = mazePanel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
        ActionMap am = mazePanel.getActionMap();

        im.put(KeyStroke.getKeyStroke("pressed UP"), "up");
        am.put("up", new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent ev) {
                if (row != 0 && array[row-1][col] != -1 && array[row-2][col] != 3 && !gameOver) {
                    int n = array[row][col];
                    array[row][col] = n == 0 || n == 1 || n == 4 || n == 5 ? 2 : 3;
                    row -= 2;
                    n = array[row][col];
                    if (n == 4)
                        scoreLabel.setText("Score: " + (score += 20));
                    else if (n == 5)
                        scoreLabel.setText("Score: " + (score += 50));
                    else if (n == 2)
                        scoreLabel.setText("Score: " + (score -= 1));
                    ellipse.y = row * SQWIDTH/2 + 3;
                    mazePanel.repaint();
                }
                if (!gameOver && array[row][col] == 6) {
                    JOptionPane.showMessageDialog(frame, "Huzzah! You found the exit! ", "Finish", JOptionPane.PLAIN_MESSAGE);
                    gameOver = true;
                }
                else if (!gameOver && checkGameOver()) {
                    JOptionPane.showMessageDialog(frame, "You got trapped! Try again!", "Game over", JOptionPane.PLAIN_MESSAGE);
                    gameOver = true;
                }
            }
        });

        im.put(KeyStroke.getKeyStroke("pressed RIGHT"), "right");
        am.put("right",new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent ev) {
                if (col != array[0].length-1 && array[row][col+1] != -1 && array[row][col+2] != 3 && !gameOver) {
                    int n = array[row][col];
                    array[row][col] = n == 0 || n == 1 || n == 4 || n == 5 ? 2 : 3;
                    col += 2;
                    n = array[row][col];
                    if (n == 4)
                        scoreLabel.setText("Score: " + (score += 20));
                    else if (n == 5)
                        scoreLabel.setText("Score: " + (score += 50));
                    else if (n == 2)
                        scoreLabel.setText("Score: " + (score -= 1));
                    ellipse.x = col * SQWIDTH/2 + 3;
                    mazePanel.repaint();
                }
                if (!gameOver && array[row][col] == 6) {
                    JOptionPane.showMessageDialog(frame, "Huzzah! You found the exit! ", "Finish", JOptionPane.PLAIN_MESSAGE);
                    gameOver = true;
                }
                else if (!gameOver && checkGameOver()) {
                    JOptionPane.showMessageDialog(frame, "You got trapped! Try again!", "Game over", JOptionPane.PLAIN_MESSAGE);
                    gameOver = true;
                }
            }
        });

        im.put(KeyStroke.getKeyStroke("pressed DOWN"), "down");
        am.put("down", new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent ev) {
                if (row != array.length-1 && array[row+1][col] != -1 && array[row+2][col] != 3 && !gameOver) {
                    int n = array[row][col];
                    array[row][col] = n == 0 || n == 1 || n == 4 || n == 5 ? 2 : 3;
                    row += 2;
                    n = array[row][col];
                    if (n == 4)
                        scoreLabel.setText("Score: " + (score += 20));
                    else if (n == 5)
                        scoreLabel.setText("Score: " + (score += 50));
                    else if (n == 2)
                        scoreLabel.setText("Score: " + (score -= 1));
                    ellipse.y = row * SQWIDTH/2 + 3;
                    mazePanel.repaint();
                }
                if (!gameOver && array[row][col] == 6) {
                    JOptionPane.showMessageDialog(frame, "Huzzah! You found the exit! ", "Finish", JOptionPane.PLAIN_MESSAGE);
                    gameOver = true;
                }
                else if (!gameOver && checkGameOver()) {
                    JOptionPane.showMessageDialog(frame, "You got trapped! Try again!", "Game over", JOptionPane.PLAIN_MESSAGE);
                    gameOver = true;
                }
            }
        });

        im.put(KeyStroke.getKeyStroke("pressed LEFT"), "left");
        am.put("left",new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent ev) {
                if (col != 0 && array[row][col-1] != -1 && array[row][col-2] != -1 && !gameOver) {
                    int n = array[row][col];
                    array[row][col] = n == 0 || n == 1 || n == 4 || n == 5 ? 2 : 3;
                    col -= 2;
                    n = array[row][col];
                    if (n == 4)
                        scoreLabel.setText("Score: " + (score += 20));
                    else if (n == 5)
                        scoreLabel.setText("Score: " + (score += 50));
                    else if (n == 2)
                        scoreLabel.setText("Score: " + (score -= 1));
                    ellipse.x = col * SQWIDTH/2 + 3;
                    mazePanel.repaint();
                }
                if (!gameOver && array[row][col] == 6) {
                    JOptionPane.showMessageDialog(frame, "Huzzah! You found the exit! ", "Finish", JOptionPane.PLAIN_MESSAGE);
                    gameOver = true;
                }
                else if (!gameOver && checkGameOver()) {
                    JOptionPane.showMessageDialog(frame, "You got trapped! Try again!", "Game over", JOptionPane.PLAIN_MESSAGE);
                    gameOver = true;
                }
            }
        });
    }

    private void setItems() {
        array[exitRow][exitCol] = 6;
        Random r = new Random();
        for (int k = 1; k < (array.length * array[0].length) / 20; k++) {
            int row = r.nextInt(array.length / 2 + 1) * 2,
                col = r.nextInt(array[0].length / 2 + 1) * 2;
            if ((row == this.row && col == this.col) || array[row][col] == 4 || array[row][col] == 5 || array[row][col] == 6)
                k--;
            else
                array[row][col] = r.nextInt(2) + 4;
        }
    }

    private boolean checkGameOver() {
        if (row == 0 && col == 0)
            return (array[row+2][col] == 3 && array[row][col+2] == 3) ||
                   (array[row+1][col] == -1 && array[row][col+2] == 3) ||
                   (array[row+2][col] == 3 && array[row][col+1] == -1);
        else if (row == 0 && col == array[0].length-1)
            return (array[row+2][col] == 3 && array[row][col-2] == 3) ||
                   (array[row+1][col] == -1 && array[row][col-2] == 3) ||
                   (array[row+2][col] == 3 && array[row][col-1] == -1);
        else if (row == array.length-1 && col == 0)
            return (array[row-2][col] == 3 && array[row][col+2] == 3) ||
                   (array[row-1][col] == -1 && array[row][col+2] == 3) ||
                   (array[row-2][col] == 3 && array[row][col+1] == -1);
        else if (row == array.length-1 && col == array[0].length-1)
            return (array[row-2][col] == 3 && array[row][col-2] == 3) ||
                   (array[row-1][col] == -1 && array[row][col-2] == 3) ||
                   (array[row-2][col] == 3 && array[row][col-1] == -1);
        else if (row == 0)
            return (array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+1] == -1) ||
                   (array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
                   (array[row+1][col] == -1 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
                   (array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
                   (array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
                   (array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
                   (array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+2] == 3);
        else if (col == 0)
            return (array[row][col+2] == 3 && array[row-1][col] == -1 && array[row+1][col] == -1) ||
                   (array[row][col+1] == -1 && array[row-2][col] == 3 && array[row+1][col] == -1) ||
                   (array[row][col+1] == -1 && array[row-1][col] == -1 && array[row+2][col] == 3) ||
                   (array[row][col+1] == -1 && array[row-2][col] == 3 && array[row+2][col] == 3) ||
                   (array[row][col+2] == 3 && array[row-2][col] == 3 && array[row+1][col] == -1) ||
                   (array[row][col+2] == 3 && array[row-1][col] == -1 && array[row+2][col] == 3) ||
                   (array[row][col+2] == 3 && array[row-2][col] == 3 && array[row+2][col] == 3);
        else if (row == array.length-1)
            return (array[row-2][col] == 3 && array[row][col-1] == -1 && array[row][col+1] == -1) ||
                   (array[row-1][col] == -1 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
                   (array[row-1][col] == -1 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
                   (array[row-1][col] == -1 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
                   (array[row-2][col] == 3 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
                   (array[row-2][col] == 3 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
                   (array[row-2][col] == 3 && array[row][col-2] == 3 && array[row][col+2] == 3);
        else if (col == array[0].length-1)
            return (array[row][col-2] == 3 && array[row-1][col] == -1 && array[row+1][col] == -1) ||
                   (array[row][col-1] == -1 && array[row-2][col] == 3 && array[row+1][col] == -1) ||
                   (array[row][col-1] == -1 && array[row-1][col] == -1 && array[row+2][col] == 3) ||
                   (array[row][col-1] == -1 && array[row-2][col] == 3 && array[row+2][col] == 3) ||
                   (array[row][col-2] == 3 && array[row-2][col] == 3 && array[row+1][col] == -1) ||
                   (array[row][col-2] == 3 && array[row-1][col] == -1 && array[row+2][col] == 3) ||
                   (array[row][col-2] == 3 && array[row-2][col] == 3 && array[row+2][col] == 3);
        else
            return (array[row-2][col] == 3 && array[row][col+1] == -1 && array[row+1][col] == -1 && array[row][col-1] == -1) ||
                   (array[row-1][col] == -1 && array[row][col+2] == 3 && array[row+1][col] == -1 && array[row][col-1] == -1) ||
                   (array[row-1][col] == -1 && array[row][col+1] == -1 && array[row+2][col] == 3 && array[row][col-1] == -1) ||
                   (array[row-1][col] == -1 && array[row][col+1] == -1 && array[row+1][col] == -1 && array[row][col-2] == 3) ||
                   (array[row-1][col] == -1 && array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
                   (array[row-2][col] == 3 && array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+1] == -1) ||
                   (array[row-2][col] == 3 && array[row+1][col] == -1 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
                   (array[row-1][col] == -1 && array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
                   (array[row-1][col] == -1 && array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
                   (array[row-2][col] == 3 && array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
                   (array[row-1][col] == -1 && array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
                   (array[row-2][col] == 3 && array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
                   (array[row-2][col] == 3 && array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
                   (array[row-2][col] == 3 && array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
                   (array[row-2][col] == 3 && array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+2] == 3);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(MazeMaker::new);
    }
}

আসল ধাঁধা তৈরির প্রক্রিয়া গভীরতার প্রথম অনুসন্ধান অ্যালগরিদম ব্যবহার করে তবে পুনরাবৃত্তির পদ্ধতির সাথে। এখানে কিভাবে এটা কাজ করে.

আমরা 2D intমানের অ্যারে দিয়ে শুরু করি , প্রতিটি উপাদান -1 হয় being এমনকি সূচকগুলির সাথে একটি এলোমেলো উপাদান বেছে নেওয়া হয় এবং এর মান 0 হয়:

-1 -1 -1 -1 -1 -1  0 -1 -1 
-1 -1 -1 -1 -1 -1 -1 -1 -1 
-1 -1 -1 -1 -1 -1 -1 -1 -1 
-1 -1 -1 -1 -1 -1 -1 -1 -1 
-1 -1 -1 -1 -1 -1 -1 -1 -1 
-1 -1 -1 -1 -1 -1 -1 -1 -1 
-1 -1 -1 -1 -1 -1 -1 -1 -1 
-1 -1 -1 -1 -1 -1 -1 -1 -1 
-1 -1 -1 -1 -1 -1 -1 -1 -1 

তারপরে প্রোগ্রামটি একটি লুপে প্রবেশ করে, উপলব্ধ কক্ষগুলির জন্য পরীক্ষা করা হবে যতক্ষণ না এটি এমন কোনও রাজ্যে পৌঁছে যায় যেখানে কোনও কক্ষ নেই। এটি বেশ কয়েকবার ঘটতে পারে এবং এটি যখন ব্যাকট্র্যাক শুরু করে। এই মুহুর্তে সমস্ত 0 সে এটি 1-এ হয়ে যায় s এছাড়াও এই সময়ে যখন এটি নির্ধারণ করে যে সেই স্থানে একটি প্রস্থান স্থাপন করা উচিত। সুতরাং এটির শেষে, অ্যারেটি দেখতে দেখতে এমনটি হতে পারে:

 0  0  0  0  0  0  1  1  1 
 0 -1 -1 -1 -1 -1  0 -1  1 
 0  0  0  0  0 -1  0 -1  1 
-1 -1 -1 -1 -1 -1  0 -1  1 
 0  0  0  0  0  0  0 -1  1 
 0 -1 -1 -1 -1 -1 -1 -1  1 
 0 -1  1  1  1  1  1 -1  1 
 0 -1  1 -1  1 -1 -1 -1  1 
 0 -1  1 -1  1  1  1  1  1 

অ্যারের নির্দিষ্ট স্পটগুলিতে যখন 1 বা 0 এর পূর্বনির্ধারিত সংখ্যা থাকে তখন লুপটি প্রস্থান করে। তারপরে, অ্যারে ব্যবহার করে, ফলাফলটি ধাঁধাটি আঁকা:

এটি সহজেই দেখতে পাওয়া যায় যে অ্যারেতে থাকা -1s দেয়ালগুলি উপস্থাপন করে এবং 0 এবং 1 এর কর্ডোর রয়েছে। আইটেমগুলি এলোমেলোভাবে ধাঁধা জুড়ে বিতরণ করা হয়। লাল উপবৃত্তটি হ'ল "প্লেয়ার" যা আপনি নিয়ন্ত্রণ করেন।

গোলকধাঁটিটি সুবিধার্থে একটি স্ক্রল ফলকে আবৃত করা হয়েছে যাতে আকারটি ফ্রেমের সর্বাধিক আকারের চেয়ে বেশি হলে আপনি বাকি ধাঁধাটি দেখতে স্ক্রোল করতে পারেন।

আমি বলব এটির সাথে একমাত্র সমস্যা হ'ল গেম চেকের সমাপ্তি কীভাবে হয়। আমি এটি করার বিভিন্ন উপায় সম্পর্কে ভেবেছিলাম, তবে আমি এগুলি সবই হার্ড-কোডিংয়ের আশ্রয় নিয়ে শেষ করেছি। এটি কীভাবে করা যায় সে সম্পর্কে আমি পরামর্শের জন্য উন্মুক্ত।

Comments

এটি সংকলন করে না। MazeMaker.java:168: error: cannot find symbol printArray(); ^ symbol: method printArray() location: class MazeMaker

— edc65

@ edc65 আমাকে জানাতে ধন্যবাদ। আমার কাছে এমন একটি পদ্ধতি আছে printArrayযা আমি অ্যারে আউটপুট ব্যবহার করতাম, তবে এটি মুছে ফেলেছিলাম এবং পদ্ধতি কলটি সরাতে ভুলে গিয়েছি।

— টিএনটি

ঠিক আছে, আমি এখন এটি চলমান আছে। এটা সুন্দর. আমি একই আইডি রেখে একই ধাঁধাটি পুনরায় চালু করার চেষ্টা করছি, তবে কাজ করছে বলে মনে হচ্ছে না।

— edc65

আমার কাছে এটি রয়েছে যাতে প্রতিবার প্রয়োগ বোতামটি চাপলে শুরু এবং শেষের অবস্থানগুলি এলোমেলো হয়ে যায়, তবে গোলকধাঁটির বিন্যাস একই থাকে। এটা কি সেভাবে হওয়া উচিত নয়?

— টিএনটি

আমি ভেবেছিলাম ঠিক একই চ্যালেঞ্জ নিয়ে আবার শুরু করার উপায়। আমার মূল উদ্বেগটি হ'ল যাচাই করা যে সর্বদা সমাধানযোগ্য (মূল প্রশ্নকারীর একটি সীমাবদ্ধতা যা আমি হার্ড পেয়েছি)

— edc65

Answer 3

পাইথন

আমি বুঝতে পারি যে আমি দলের জন্য দেরি করেছি, তবে এই চ্যালেঞ্জটি গ্রহণ করার জন্য আমি এখানেই আছি। আমি পাইগেম শিখতে প্রায় পাইনি বলেই আমি পাঠ্যকে ভিত্তি করেছিলাম। এটি পাইথন ৩. কাঁচা_পিন্ডে ইনপুট পরিবর্তন করুন এবং এটি পাইথন 2 এও কাজ করা উচিত।

হুক (প্রস্থান) "জে" দ্বারা প্রতিনিধিত্ব করা হয়। "ডাব্লু" মুকুট (50)। "জি" হ'ল সোনার নগেটস (20)। প্লেয়ার হলেন "ও"। আমি প্লেয়ারটির জন্য "পি" ব্যবহার করে পরীক্ষা করেছি, তবে সনাক্ত করতে আমি "ও" আরও সহজ পেয়েছি।

আমি স্ট্যান্ডার্ড গভীরতার প্রথম গোলকধাঁধা প্রজন্ম ব্যবহার করেছি, তারপরে স্বর্ণ, মুকুট, হুক এবং বর্তমান প্লেয়ারের অবস্থান যুক্ত করব। সমস্ত ধন প্রাপ্ত হতে পারে এমন মানদণ্ড আমি প্রয়োগ করি নি।

import random

direcs = {'n':[0,-1],
          's':[0,1],
          'w':[-1,0],
          'e':[1,0]}
dirs = ['n','s','e','w']

class maze_space(object):
    def __init__(self):
        self.n = 0
        self.s = 0
        self.e = 0
        self.w = 0
        self.visited = 0
        self.contents = ' '

    def mirror(self,drct,val):
        if drct == 'n' : self.s = val
        if drct == 's' : self.n = val
        if drct == 'e' : self.w = val
        if drct == 'w' : self.e = val

class MazeGame(object):

    def __init__(self,horiz=12,vert=8):
        self.completed = 0
        self.score = 0
        self.grid = [[maze_space() for x in range(horiz)] for y in range(vert)]

        def walk(y,x):
            self.grid[y][x].visited = 1
            drs = self.make_dir_list(y, x)
            random.shuffle(drs)
            for dr in drs:
                yy = y + direcs[dr][1]
                xx = x + direcs[dr][0]
                if not self.grid[yy][xx].visited:
                    setattr(self.grid[y][x], dr, 1)
                    self.grid[yy][xx].mirror(dr, 1)
                    walk(yy, xx)

        y, x = self.pick_row_col()
        walk(y, x)
        self.maze_populate()
        self.printmaze()

    def main_loop(self):
        while not self.completed:
            move = get_move(self.grid, self.cury, self.curx)
            self.make_move(move)
            self.printmaze()

    def pick_row_col(self):
        '''pick a random cell in the grid'''
        row = random.randint(0, len(self.grid) - 1)
        col = random.randint(0, len(self.grid[0]) - 1)
        return row, col

    def make_dir_list(self, y, x):
        '''return list of available move directions'''
        drs = dirs[:]
        if x == 0 : drs.pop(drs.index('w'))
        if y == 0 : drs.pop(drs.index('n'))
        if x == len(self.grid[0]) - 1 : drs.pop(drs.index('e'))
        if y == len(self.grid) - 1 : drs.pop(drs.index('s'))
        return drs

    def maze_populate(self):
        # populate maze with crowns and gold nuggets
        for treasure in ['G', 'W']:
            for _ in range(random.randint(1, len(self.grid[0]))):
                yy, xx = self.pick_row_col()
                self.grid[yy][xx].contents = treasure

        self.cury, self.curx = self.pick_row_col() # start position
        exity, exitx = self.pick_row_col() # hook (exit) position
        #make sure start is not on top of exit
        while self.cury == exity and self.curx == exitx :
            exitx = random.randint(0, len(self.grid[0]) - 1)

        self.grid[self.cury][self.curx].contents = 'O'
        self.grid[exity][exitx].contents = 'J'

    def make_move(self,dr):
        self.grid[self.cury][self.curx].visited += 1
        self.grid[self.cury][self.curx].contents = '.'
            # player has walked twice -> disable
        if self.grid[self.cury][self.curx].visited >= 3:
            self.grid[self.cury][self.curx].contents = 'X'
            drs = self.make_dir_list(self.cury, self.curx)
            for d in drs:
                yyy = self.cury + direcs[d][1]
                xxx = self.curx + direcs[d][0]
                self.grid[yyy][xxx].mirror(d,0)

        yy = self.cury + direcs[dr][1]
        xx = self.curx + direcs[dr][0]
        if self.grid[yy][xx].contents == 'J': self.completed = 1
        if self.grid[yy][xx].contents == 'W': self.score += 50
        if self.grid[yy][xx].contents == 'G': self.score += 20
        if self.grid[yy][xx].contents == '.': self.score -= 1
        self.grid[yy][xx].contents = 'O'
        self.cury, self.curx = yy, xx

    def printmaze(self):
        if self.completed: print('\nMaze complete.  Good job!')
        print('Score: %d'%self.score)
        print('|'+''.join('---' for _ in self.grid[0]))
        for line in self.grid:
            print('|' + ''.join(' %s '%x.contents if x.e else ' %s|'%
                                x.contents for x in line))
            print('|' + ''.join('  -' if x.s else '---' for x in line))

def get_params():
    hor = input('width (default=12): ')
    hor = int(hor) if hor else 12
    ver = input('height (default=8): ')
    ver = int(ver) if ver else 8
    rseed = input('seed : ')
    rseed = int(rseed) if rseed else random.randint(1,65535)
    print(rseed)
    random.seed(rseed)
    print("'J' = hook (exit)\n'O' = Player")
    print("'G' = gold nugget (20 points)\n'W' = Crown (50 points)")
    print('Player may only tread on a given tile twice')
    return hor,ver

def get_move(grid, y, x):
    choice = input('where do you want to move %s q to quit: '%dirs)
    if choice == 'q' : exit()
    if choice in dirs and getattr(grid[y][x],choice): return choice
    return get_move(grid, y, x)

def main():
    hor,ver = get_params()
    maze = MazeGame(hor,ver)
    maze.main_loop()

if __name__ == '__main__':
    main()