-
Larawan 1 ngdalawampu't isa
Ang Raspberry Pi 2 ay isang nakakagulat na may kakayahang aparato, isinasaalang-alang ang sub- £ 30 na presyo. Dumating ito sa isang bersyon ng paunang naka-install na Minecraft, kasama ang isang API na nagbibigay-daan sa iyo upang sumulat ng code upang patakbuhin sa virtual na mundo. Ginagawa mo ito sa Python, na simpleng matutunan. Ang kumbinasyon ng Pi, Python at Minecraft ay nagbibigay ng isang mahusay na pagkakataon upang simulan ang paggalugad ng mga posibilidad ng programa. At ang pangingilig sa pakiramdam ng isang bahay na nagtatayo mismo sa isang virtual na tanawin ay hindi lamang para sa mga bata, alinman.
kung paano sasabihin kung ang iyong gpu ay namamatay
Pag-iskrip sa Minecraft
Ang Minecraft ay isang bukas na laro ng sandbox na walang sumusunod na linya ng balangkas. Minsan inilalarawan ito bilang virtual Lego, dahil ang manlalaro ay maaaring bumuo ng anumang uri ng istraktura gamit ang mga bloke na gusto nila. Ang bersyon na naka-bundle sa Raspberry Pi ay may isang limitadong tampok na tampok na naaangkop sa papel na pang-edukasyon - kaya't hindi mo kailangang mag-alala tungkol sa paghabol sa iyo ng mga zombie, halimbawa. Ang pakikipag-ugnay sa mundong ito ay hindi nangangailangan ng espesyal na pag-set up, kamakailan lamang na pagtatayo ng Raspbian OS kasama ang isang kapaligiran sa pagprograma. Gusto kong pumili para sa Geany, na maaari mong mai-install sa pamamagitan ng pagbubukas ng LXTerminal at pagta-type:
sudo apt-get install geany
Magsimula tayo sa pamamagitan ng paglikha ng isang script para sa pagbuo ng isang bahay sa harap ng manlalaro - ngunit sa halip na sampalin lamang ang isa sa lugar, isasabuhay natin ito. Tatayo rin kami sa iba't ibang mga setting na maaaring mai-configure, na magpapahintulot sa manlalaro na mag-eksperimento sa iba't ibang mga sukat at materyales. Gagawin din nitong modular ang programa, kaya maaari itong magamit bilang batayan sa paglikha ng mas sopistikadong mga wellness.
Upang magawa ang code, i-load ito sa Geany pagkatapos simulan ang Minecraft at lumikha ng isang bagong mundo. Pindutin ang Tab key upang palabasin ang cursor mula sa window ng Minecraft at i-click ang cog icon sa Geany (o pindutin ang F5) upang ilunsad ang script. Dapat mong makita ang isang bahay na mahiwagang magtipun-tipon mismo. Kung hindi mo, subukang lumingon - maaaring nasa likuran mo ito! Maaari mong makita ang script sa pagkilos dito . Kaya paano gumagana ang script? Kaya, una ay bubukas ito ng isang link sa Minecraft:
i-import ang mcpi.minecraft bilang minecraft, oras mc = minecraft.Minecraft.create ()
Sa Python, mahalagang bigyang-pansin ang indentation, dahil iyan ang code ay nahahati sa mga bloke. Sa kasong ito, ang parehong mga linya ay flush gamit ang kaliwang margin: ang unang linya ay na-import ang mga library ng Minecraft at Time at ang pangalawa ay lumilikha ng isang bagay na Minecraft na magagamit namin sa kabuuan. Ang susunod na 25 mga linya ay nagtakda ng ilang mga variable para sa mga bloke na gagamitin namin upang masangguni namin ang mga ito bilang, sabi, mga wood_planks kaysa sa pamamagitan ng kanilang block ID (5, sa kasong ito). Pagkatapos ay ipahiwatig namin kung alin sa mga bloke na ito ang gagamitin para sa mga dingding, na para sa bubong at iba pa. Madali nating mababago ang pagtatayo ng bahay nang buo sa pamamagitan ng pagpapalit ng mga pader ng ladrilyo para sa cobblestone, halimbawa. Sa wakas, itinakda namin ang lapad, haba at taas ng aming ninanais na tirahan.
Tinatawag namin ngayon ang Minecraft function mc.player.getTilePos () upang hanapin ang manlalaro sa tanawin, at ang mga halagang bumalik ay ginagamit pagkatapos upang lumikha ng dalawang variable, kaliwa at ibaba, upang ilarawan kung saan ang unang sulok ng tirahan ay .
Pagkatapos noon, ang istraktura ng script ay tumutugma sa proseso ng Minecraft ng manu-manong pagbuo ng isang bahay. Nagsisimula kami sa pamamagitan ng pag-clear ng isang puwang upang kung pipiliin ng manlalaro na itayo ang bahay sa loob, sabihin, isang bundok, ang lugar ng sala ay hindi magiging solidong bato. Narito ang bloke ng code - ang pagpapaandar sa Python - ginagawa ito:
def clear_house (nukleyar):
kung nuklear == Totoo:
blast_zone = 20
iba pa:
blast_zone = 0
mc.setBlocks (left-blast_zone, player_
ground, ilalim + blast_zone, left + width + blast_
zone, player_ground + taas + blast_
zone + 10, ilalim-haba-blast_zone, air_block)
Kapag tumawag kami sa clear_house, ipinapasa namin ang parameter na nukleyar. Mayroon itong halaga na Tama o Mali. Maaari mong subukang tawagan ito gamit ang True upang malinis ang isang mas malaking dami sa paligid ng target na lugar, o tawagan ito sa Maling upang makulong ang clearance sa mga panloob na sukat ng bahay. Sa Minecraft, ang pagpapaandar ng mc.setBlocks ay ginagamit upang lumikha ng isang kubo ng mga bloke sa pamamagitan ng pagpasa nito sa mga co-ordinate, sa tatlong sukat, ng kabaligtaran na mga sulok na sinusundan ng uri ng block na nais mong gamitin. Sa pagkakataong ito, nililinaw namin ang isang puwang, kaya gumagamit kami ng hangin.
Kapag na-clear na namin ang puwang oras na upang magpatuloy sa konstruksyon. Ang bawat isa sa mga yugto ng konstruksyon na ito ay nagaganap sa sarili nitong pagpapaandar. Sa pagtatapos ng script, makikita mo ang isang pagpapaandar na tinatawag na pangunahing (), na kumokontrol sa daloy ng programa sa pamamagitan ng pagtawag sa bawat yugto ng konstruksyon. Sa pamamagitan ng pagbibigay ng pangalan sa aming mga pagpapaandar nang matino at pagtawag sa kanila mula sa pangunahing (), madaling maunawaan kung ano ang ginagawa ng programa:
def main ():
clear_house (Mali)
start_pos = [kaliwa, ibaba, player_
lupa]
build_floor (start_pos)
course = build_walls (start_pos)
add_door (door_position)
oras. tulog (antala * 10)
build_roof (start_pos, kurso)
Ang susunod na pagpapaandar na tinatawag na pangunahing () ay nagtatayo ng sahig - gumagamit ito ng mc. setBlocks muli upang mag-ukit ng isang pundasyon (para sa artistikong epekto) at pagkatapos ay magdagdag ng isang kubo ng mga tile sa sahig na may lalim ng isang bloke upang lumikha ng isang solidong sahig sa aming bahay.
kung paano malaman kung ang iyong aparato ay rooted
Pagbuo ng mga pader
Ang pagpapaandar ng build_walls ang puso ng programa. Ang pinaka mahusay na paraan upang likhain ang shell ng isang bahay ay ang pagsampal ng isang solidong kubo ng mga brick at pagkatapos ay gumamit ng clear_house upang maukit ang loob. Gayunpaman, nais naming lumitaw ang bahay upang mabuo ang sarili nito, kaya kailangan naming maglagay ng mga bloke nang paisa-isa, sunod-sunod. Narito ang isang pinasimple na bersyon ng code sa pagbuo ng pader:
def build_course (start_pos, direksyon,
kurso):
mga bloke = 1
current_horiz = start_pos [0]
current_vert = start_pos [1]
kung direksyon == pataas o
direksyon == pababa:
number_of_blocks = haba
iba pa:
number_of_blocks = lapad
habang hinaharangan
ground + course, current_vert, wall_block)
kung direksyon == pataas:
kasalukuyang_vert- = 1
direksyon ng elif == pababa:
kasalukuyang_vert + = 1
direksyon ng elif == kanan:
kasalukuyang_horiz + = 1
iba pa:
kasalukuyang_horiz- = 1
blocks = blocks + 1 # lumipat sa susunod na bloke
oras. tulog (antala)
Nagsisimula kami sa pamamagitan ng pag-iimbak ng panimulang posisyon - ito ang magiging posisyon ng huling bloke na inilatag mula sa nakaraang kurso ng mga bloke. Pagkatapos ay tinukoy namin kung gaano karaming mga bloke ang ilalagay, depende sa kung susundan namin ang haba ng gusali o ang lapad nito.
Ang yugto ng pagbuo ay nakapaloob sa loob ng bloke habang - ito ay patuloy na tumatakbo hanggang mailatag namin ang lahat ng mga bloke. Naglalagay ang mc.setBlock ng isang solong bloke sa mga co-ordinate na ipinakita, pagkatapos ay nagdaragdag ng isa sa mga co-ordinate na nakasalalay sa direksyon kung saan kami inilalagay. Ang epekto ay ang mga bloke ay inilalagay kasama ng isang dingding bago paikutin ang isang sulok at magpatuloy sa isang rektanggulo hanggang makumpleto ang kurso.
kung paano madagdagan ang mabilis na iskor ng mabilis
Ang pangwakas na bersyon ng code ay medyo kasangkot, pagdaragdag ng mga bintana sa bawat dingding. Ang mga bintana ay pabagu-bago ng laki upang ang mga ito ay kalahati ng haba ng dingding at nakasentro. Itinatala din nito ang posisyon para sa pintuan; idinagdag ito kapag naitayo na ang mga pader. Kinokontrol ang mga kurso mula sa pagpapaandar ng build_walls, na inuulit ang pagpapaandar ng build_course para sa bawat kurso ng mga bloke hanggang sa maabot nito ang huling taas.
Maaari mo ring subukan ang pagbuo ng iyong bahay sa karagatan o sa himpapawid - gawin ito sa pamamagitan ng pagdoble sa spacebar upang lumipad, pagkatapos ay pindutin muli upang itaas ang iyong sarili bago patakbuhin ang script. Baguhin ang mga variable ng wall_block at roof_block upang makita kung ano ang mangyayari kung lumikha ka ng mga pader o bubong ng ginto o, sa katunayan, lava. Maaari kang magdagdag ng iyong sariling mga bloke sa pamamagitan ng pagkonsulta sa buong listahan dito , at pagdaragdag ng nauugnay na variable sa script. Ang mga mas mapaghamong pagbabago ay maaaring magsama ng pagdaragdag ng maraming palapag sa istraktura kung ang variable ng taas ay nakatakda sa isang malaking sapat na halaga. Mag-ehersisyo kung paano magdagdag ng mga turrets, halimbawa, at mayroon kang mga paggawa ng isang kastilyo ng Minecraft.
Ang mga pag-aayos na ito ay maaaring tunog hindi gaanong mahalaga, ngunit nagprograma ako ng propesyonal nang higit sa 20 taon at nakakakuha pa rin ako ng kilig kapag gumagana ang isang snippet ng code ayon sa nilalayon. Kung hindi mo pa nai-program bago, sana ay bigyan mo ito - at kung mayroon kang isang fan ng Minecraft sa sambahayan, iminumungkahi kong palayain sila sa code at makita kung saan sila dadalhin. Mahahanap mo ang mga link sa mga mapagkukunan ng Minecraft Pi sa kevpartner.co.uk/programming .
