daily pastebin goal
58%
SHARE
TWEET

Untitled

a guest Jul 19th, 2018 58 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. 1: #include <iostream>
  2.    2: #include <string>
  3.    3: #include <vector>
  4.    4: using namespace std;
  5.    5: //Laaja Ohjelmointi 1
  6.    6: //Harjoitustyö
  7.    7: //"EinStein würfelt nicht"
  8.    8:
  9.    9: int arpa ()
  10.   10: {
  11.   11:    const int RMAX = RAND_MAX + 1;
  12.   12:    double luku = rand ();
  13.   13:    luku = luku * 6;
  14.   14:    luku = luku / RMAX;
  15.   15:    luku = luku + 1;
  16.   16:    return static_cast<int>(luku);
  17.   17: }
  18.   18:
  19.   19: void kysySiemenluku ()
  20.   20: {
  21.   21:    int siemenluku=0;
  22.   22:    cout << "Anna siemenluku" << endl << "> ";
  23.   23:    cin >> siemenluku;
  24.   24:    srand(siemenluku);
  25.   25: }
  26.   26:
  27.   27: enum Pelaaja
  28.   28: {
  29.   29:    Musta,
  30.   30:      Valkea
  31.   31: };
  32.   32:
  33.   33: struct Kivi
  34.   34: {
  35.   35:    bool vari;
  36.   36:    int luku;
  37.   37: };
  38.   38:
  39.   39: struct Ruutu
  40.   40: {
  41.   41:    int kivi;
  42.   42:    bool tyhja;
  43.   43: };
  44.   44:
  45.   45: bool onkoElossa(vector<vector<Ruutu> > pelilauta, int kivinro)
  46.   46: {
  47.   47:    for (int y = 0; y < 5; ++y)
  48.   48:    {
  49.   49:       for (int x = 0; x < 5; ++x)
  50.   50:       {
  51.   51:          if(pelilauta.at(y).at(x).kivi == kivinro)
  52.   52:            {
  53.   53:               return true;
  54.   54:            }
  55.   55:          
  56.   56:       }
  57.   57:    }
  58.   58:    return false;
  59.   59: }
  60.   60:    
  61.   61: vector<vector<Ruutu> > muodostaAlkuasetelma()
  62.   62: {
  63.   63:    Ruutu kivi = {0, false};
  64.   64:    vector<Ruutu> rivi;
  65.   65:    vector<vector<Ruutu> > pelilauta;
  66.   66:    bool vuoro;
  67.   67:    int kivinro = arpa();
  68.   68:      
  69.   69:    for (int i = 0; i <= 4; ++i)
  70.   70:    {
  71.   71:       rivi.push_back(kivi);
  72.   72:    }
  73.   73:    
  74.   74:    for(int j = 0; j <= 4; ++j)  
  75.   75:    {      
  76.   76:       pelilauta.push_back(rivi);
  77.   77:    }
  78.   78:
  79.   79:    
  80.   80:    //koordinaatit(y,x)
  81.   81:      
  82.   82:    while(onkoElossa(pelilauta, kivinro) == true)
  83.   83:    {
  84.   84:       kivinro = arpa();
  85.   85:    }
  86.   86:    
  87.   87:    pelilauta.at(0).at(0).kivi = kivinro;
  88.   88:    pelilauta.at(4).at(4).kivi = -kivinro;
  89.   89:    
  90.   90:    while(onkoElossa(pelilauta, kivinro) == true)
  91.   91:    {
  92.   92:       kivinro = arpa();
  93.   93:    }
  94.   94:    
  95.   95:    pelilauta.at(0).at(1).kivi = kivinro;
  96.   96:    pelilauta.at(4).at(3).kivi = -kivinro;
  97.   97:    
  98.   98:    while(onkoElossa(pelilauta, kivinro)  == true)
  99.   99:    {                        
  100.  100:       kivinro = arpa();
  101.  101:    }
  102.  102:    
  103.  103:    pelilauta.at(0).at(2).kivi = kivinro;
  104.  104:    pelilauta.at(4).at(2).kivi = -kivinro;
  105.  105:    
  106.  106:    while(onkoElossa(pelilauta, kivinro) == true)
  107.  107:    {
  108.  108:       kivinro = arpa();
  109.  109:    }
  110.  110:    
  111.  111:    pelilauta.at(1).at(0).kivi = kivinro;
  112.  112:    pelilauta.at(3).at(4).kivi = -kivinro;
  113.  113:    
  114.  114:    while(onkoElossa(pelilauta, kivinro) == true)
  115.  115:    {
  116.  116:       kivinro = arpa();
  117.  117:    }
  118.  118:    
  119.  119:    pelilauta.at(1).at(1).kivi = kivinro;  
  120.  120:    pelilauta.at(3).at(3).kivi = -kivinro;
  121.  121:    
  122.  122:    while (onkoElossa(pelilauta, kivinro) == true)
  123.  123:    {
  124.  124:       kivinro = arpa();
  125.  125:    }
  126.  126:    
  127.  127:    pelilauta.at(2).at(0).kivi = kivinro;
  128.  128:    pelilauta.at(2).at(4).kivi = -kivinro;
  129.  129:    
  130.  130:    //(0,0),(0,1),(0,2)
  131.  131:    //(1,0),(1,1)
  132.  132:    //(2,0)
  133.  133:    //(2,4)
  134.  134:    //(3,4),(3,3)
  135.  135:    //(4,4),(4,3),(4,2)
  136.  136:    
  137.  137:          
  138.  138:       return pelilauta;
  139.  139:      
  140.  140: }
  141.  141:
  142.  142: vector<vector<Ruutu> > tulostaPelilauta(vector<vector<Ruutu> > pelilauta);
  143.  143: {
  144.  144:    
  145.  145:    vector<vector<Ruutu> > pelilauta = muodostaAlkuasetelma();
  146.  146:    for (int k = 0; k < 25; ++k)
  147.  147:    {
  148.  148:    }
  149.  149:    
  150.  150: }
  151.  151:
  152.  152: enum Liike
  153.  153: {
  154.  154:    //Mustan liikkeet  
  155.  155:    ita,
  156.  156:      etela,
  157.  157:      kaakko,
  158.  158:      //Valkean liikkeet
  159.  159:      lansi,
  160.  160:      pohjoinen,
  161.  161:      luode
  162.  162: };
  163.  163:
  164.  164: void siirto(vector<vector<Ruutu> > pelilauta);
  165.  165: {
  166.  166:    int siirto = 0;
  167.  167:    Pelaaja pelaaja;
  168.  168:    int numero = 0;
  169.  169:    //if (vuoro=true)
  170.  170:    //kivi=kivi.numero
  171.  171:    //if (vuoro=false)
  172.  172:    //kivi=kivi.vari
  173.  173:    //int liike = kiven vanha koordinaatti
  174.  174:    
  175.  175:    //tulostaPelilauta();
  176.  176:    cout << pelaaja << " pelaaja, siirrä kiveä " << numero << endl << "> ";
  177.  177:    cin >> siirto;
  178.  178:    
  179.  179:    switch (siirto)
  180.  180:    {
  181.  181:      
  182.  182:     case 6:
  183.  183:       // liike=pelilauta.at(y+1).at(x).kivi;  
  184.  184:       break;
  185.  185:     case 2:
  186.  186:       // liike=pelilauta.at(y).at(x+1).kivi;
  187.  187:       break;
  188.  188:     case 3:
  189.  189:       // liike=pelilauta.at(y+1).at(x+1).kivi;
  190.  190:       break;
  191.  191:     case 4:
  192.  192:       // liike=pelilauta.at(y).at(x-1).kivi;
  193.  193:       break;
  194.  194:     case 8:
  195.  195:       // liike=pelilauta.at(y-1).at(x).kivi;
  196.  196:       break;
  197.  197:     case 9:
  198.  198:       // liike=pelilauta.at(y-1).at(x-1).kivi;
  199.  199:       break;
  200.  200:     default:
  201.  201:       cout << "VIRHE: Virheellinen suunta." << endl;
  202.  202:       siirto(pelilauta);
  203.  203:    }
  204.  204:    
  205.  205:    //if (laiton siirto)
  206.  206:    //jos kivi.vari == musta
  207.  207:    //laittomat siirrot
  208.  208:    //4, 8, 7, 1, 9
  209.  209:    //if (kivi.vari == valkea)
  210.  210:    //6, 2, 3, 1, 9
  211.  211:    {
  212.  212:       cout << "VIRHE: Virheellinen suunta." << endl;
  213.  213:       siirto(pelilauta);
  214.  214:    }
  215.  215:    
  216.  216:    //if (OOB)
  217.  217:    //if liike < ulompi.size tai liike > ulompi.size
  218.  218:    //tai liike < sisempi.size tai liike > sisempi.size
  219.  219:    //joka siirron tarkistu: on pysyttävä annettujen koordinaattien joukossa
  220.  220:    //tarkistetaan vaan jos ollaan reunaruudussa
  221.  221:    //tietyistä koordinaateista ei saa siirtyä tiettyyn suuntaan
  222.  222:    {
  223.  223:       cout << "VIRHE: Yritit siirtyä ulos laudalta." << endl;
  224.  224:       siirto(pelilauta);
  225.  225:    }
  226.  226:    
  227.  227: }
  228.  228:
  229.  229: bool voittoasema(Pelaaja pelaaja)
  230.  230: {
  231.  231:    if (pelaaja==Musta)
  232.  232:    {
  233.  233:       //pelilauta.at(4).at(4).kivi == musta;
  234.  234:       //laudan läpikäynti, etsitään valkoisia kiviä
  235.  235:       //jos on, return false
  236.  236:    }
  237.  237:    
  238.  238:    if (pelaaja==Valkea)
  239.  239:    {
  240.  240:       //pelilauta.at(0).at(0).kivi == valkea;
  241.  241:       //laudan läpikäynti, etsitään mustia
  242.  242:       //jos on, return false
  243.  243:      
  244.  244:    }
  245.  245:    
  246.  246: }
  247.  247:
  248.  248:
  249.  249: int main ()
  250.  250: {
  251.  251:    Pelaaja pelaaja;
  252.  252:    pelaaja = Musta;
  253.  253:    kysySiemenluku ();  
  254.  254:    
  255.  255:    muodostaAlkuasetelma ();
  256.  256:    
  257.  257:    while(true)
  258.  258:    {
  259.  259:      
  260.  260:       arpa();
  261.  261:       //tulostetaan vuorossa oleva kivi
  262.  262:       //jos arvottua kiveä ei ole, etsitään siitä seuraavat kivet ja
  263.  263:       //pyydetään valitsemaan ylempi tai alempi
  264.  264:      
  265.  265:       siirto();
  266.  266:      
  267.  267:      
  268.  268:      
  269.  269:      
  270.  270:      
  271.  271:      
  272.  272:      
  273.  273:      
  274.  274:       if (voittoasema()==true)
  275.  275:       {
  276.  276:          cout << pelaaja << " pelaaja voitti pelin!" << endl;
  277.  277:       }
  278.  278:      
  279.  279:       if (pelaaja == Musta)
  280.  280:       {
  281.  281:          pelaaja = Valkea;
  282.  282:       }
  283.  283:       else
  284.  284:       {
  285.  285:          pelaaja = Musta;
  286.  286:       }
  287.  287:      
  288.  288:    }
  289.  289:    
  290.  290:    
  291.  291:    
  292.  292:    
  293.  293:    
  294.  294:    
  295.  295:    return EXIT_SUCCESS;
  296.  296: }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top