├── .gitignore ├── LICENSE ├── README.md ├── img ├── git_bash_setup_unicode.png └── git_bash_setup_unicode_2.png ├── legacy ├── main.go └── utils.go ├── main.go ├── mapas ├── mapa01.txt ├── mapa02.txt └── mapa03.txt └── utils.go /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | 6 | # Folders 7 | _obj 8 | _test 9 | 10 | # Architecture specific extensions/prefixes 11 | *.[568vq] 12 | [568vq].out 13 | 14 | *.cgo1.go 15 | *.cgo2.c 16 | _cgo_defun.c 17 | _cgo_gotypes.go 18 | _cgo_export.* 19 | 20 | _testmain.go 21 | 22 | *.exe 23 | *.test 24 | *.prof 25 | pacgo 26 | .vscode/* 27 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU AFFERO GENERAL PUBLIC LICENSE 2 | Version 3, 19 November 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | Preamble 9 | 10 | The GNU Affero General Public License is a free, copyleft license for 11 | software and other kinds of works, specifically designed to ensure 12 | cooperation with the community in the case of network server software. 13 | 14 | The licenses for most software and other practical works are designed 15 | to take away your freedom to share and change the works. By contrast, 16 | our General Public Licenses are intended to guarantee your freedom to 17 | share and change all versions of a program--to make sure it remains free 18 | software for all its users. 19 | 20 | When we speak of free software, we are referring to freedom, not 21 | price. Our General Public Licenses are designed to make sure that you 22 | have the freedom to distribute copies of free software (and charge for 23 | them if you wish), that you receive source code or can get it if you 24 | want it, that you can change the software or use pieces of it in new 25 | free programs, and that you know you can do these things. 26 | 27 | Developers that use our General Public Licenses protect your rights 28 | with two steps: (1) assert copyright on the software, and (2) offer 29 | you this License which gives you legal permission to copy, distribute 30 | and/or modify the software. 31 | 32 | A secondary benefit of defending all users' freedom is that 33 | improvements made in alternate versions of the program, if they 34 | receive widespread use, become available for other developers to 35 | incorporate. Many developers of free software are heartened and 36 | encouraged by the resulting cooperation. However, in the case of 37 | software used on network servers, this result may fail to come about. 38 | The GNU General Public License permits making a modified version and 39 | letting the public access it on a server without ever releasing its 40 | source code to the public. 41 | 42 | The GNU Affero General Public License is designed specifically to 43 | ensure that, in such cases, the modified source code becomes available 44 | to the community. It requires the operator of a network server to 45 | provide the source code of the modified version running there to the 46 | users of that server. Therefore, public use of a modified version, on 47 | a publicly accessible server, gives the public access to the source 48 | code of the modified version. 49 | 50 | An older license, called the Affero General Public License and 51 | published by Affero, was designed to accomplish similar goals. This is 52 | a different license, not a version of the Affero GPL, but Affero has 53 | released a new version of the Affero GPL which permits relicensing under 54 | this license. 55 | 56 | The precise terms and conditions for copying, distribution and 57 | modification follow. 58 | 59 | TERMS AND CONDITIONS 60 | 61 | 0. Definitions. 62 | 63 | "This License" refers to version 3 of the GNU Affero General Public License. 64 | 65 | "Copyright" also means copyright-like laws that apply to other kinds of 66 | works, such as semiconductor masks. 67 | 68 | "The Program" refers to any copyrightable work licensed under this 69 | License. Each licensee is addressed as "you". "Licensees" and 70 | "recipients" may be individuals or organizations. 71 | 72 | To "modify" a work means to copy from or adapt all or part of the work 73 | in a fashion requiring copyright permission, other than the making of an 74 | exact copy. The resulting work is called a "modified version" of the 75 | earlier work or a work "based on" the earlier work. 76 | 77 | A "covered work" means either the unmodified Program or a work based 78 | on the Program. 79 | 80 | To "propagate" a work means to do anything with it that, without 81 | permission, would make you directly or secondarily liable for 82 | infringement under applicable copyright law, except executing it on a 83 | computer or modifying a private copy. Propagation includes copying, 84 | distribution (with or without modification), making available to the 85 | public, and in some countries other activities as well. 86 | 87 | To "convey" a work means any kind of propagation that enables other 88 | parties to make or receive copies. Mere interaction with a user through 89 | a computer network, with no transfer of a copy, is not conveying. 90 | 91 | An interactive user interface displays "Appropriate Legal Notices" 92 | to the extent that it includes a convenient and prominently visible 93 | feature that (1) displays an appropriate copyright notice, and (2) 94 | tells the user that there is no warranty for the work (except to the 95 | extent that warranties are provided), that licensees may convey the 96 | work under this License, and how to view a copy of this License. If 97 | the interface presents a list of user commands or options, such as a 98 | menu, a prominent item in the list meets this criterion. 99 | 100 | 1. Source Code. 101 | 102 | The "source code" for a work means the preferred form of the work 103 | for making modifications to it. "Object code" means any non-source 104 | form of a work. 105 | 106 | A "Standard Interface" means an interface that either is an official 107 | standard defined by a recognized standards body, or, in the case of 108 | interfaces specified for a particular programming language, one that 109 | is widely used among developers working in that language. 110 | 111 | The "System Libraries" of an executable work include anything, other 112 | than the work as a whole, that (a) is included in the normal form of 113 | packaging a Major Component, but which is not part of that Major 114 | Component, and (b) serves only to enable use of the work with that 115 | Major Component, or to implement a Standard Interface for which an 116 | implementation is available to the public in source code form. A 117 | "Major Component", in this context, means a major essential component 118 | (kernel, window system, and so on) of the specific operating system 119 | (if any) on which the executable work runs, or a compiler used to 120 | produce the work, or an object code interpreter used to run it. 121 | 122 | The "Corresponding Source" for a work in object code form means all 123 | the source code needed to generate, install, and (for an executable 124 | work) run the object code and to modify the work, including scripts to 125 | control those activities. However, it does not include the work's 126 | System Libraries, or general-purpose tools or generally available free 127 | programs which are used unmodified in performing those activities but 128 | which are not part of the work. For example, Corresponding Source 129 | includes interface definition files associated with source files for 130 | the work, and the source code for shared libraries and dynamically 131 | linked subprograms that the work is specifically designed to require, 132 | such as by intimate data communication or control flow between those 133 | subprograms and other parts of the work. 134 | 135 | The Corresponding Source need not include anything that users 136 | can regenerate automatically from other parts of the Corresponding 137 | Source. 138 | 139 | The Corresponding Source for a work in source code form is that 140 | same work. 141 | 142 | 2. Basic Permissions. 143 | 144 | All rights granted under this License are granted for the term of 145 | copyright on the Program, and are irrevocable provided the stated 146 | conditions are met. This License explicitly affirms your unlimited 147 | permission to run the unmodified Program. The output from running a 148 | covered work is covered by this License only if the output, given its 149 | content, constitutes a covered work. This License acknowledges your 150 | rights of fair use or other equivalent, as provided by copyright law. 151 | 152 | You may make, run and propagate covered works that you do not 153 | convey, without conditions so long as your license otherwise remains 154 | in force. You may convey covered works to others for the sole purpose 155 | of having them make modifications exclusively for you, or provide you 156 | with facilities for running those works, provided that you comply with 157 | the terms of this License in conveying all material for which you do 158 | not control copyright. Those thus making or running the covered works 159 | for you must do so exclusively on your behalf, under your direction 160 | and control, on terms that prohibit them from making any copies of 161 | your copyrighted material outside their relationship with you. 162 | 163 | Conveying under any other circumstances is permitted solely under 164 | the conditions stated below. Sublicensing is not allowed; section 10 165 | makes it unnecessary. 166 | 167 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 168 | 169 | No covered work shall be deemed part of an effective technological 170 | measure under any applicable law fulfilling obligations under article 171 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or 172 | similar laws prohibiting or restricting circumvention of such 173 | measures. 174 | 175 | When you convey a covered work, you waive any legal power to forbid 176 | circumvention of technological measures to the extent such circumvention 177 | is effected by exercising rights under this License with respect to 178 | the covered work, and you disclaim any intention to limit operation or 179 | modification of the work as a means of enforcing, against the work's 180 | users, your or third parties' legal rights to forbid circumvention of 181 | technological measures. 182 | 183 | 4. Conveying Verbatim Copies. 184 | 185 | You may convey verbatim copies of the Program's source code as you 186 | receive it, in any medium, provided that you conspicuously and 187 | appropriately publish on each copy an appropriate copyright notice; 188 | keep intact all notices stating that this License and any 189 | non-permissive terms added in accord with section 7 apply to the code; 190 | keep intact all notices of the absence of any warranty; and give all 191 | recipients a copy of this License along with the Program. 192 | 193 | You may charge any price or no price for each copy that you convey, 194 | and you may offer support or warranty protection for a fee. 195 | 196 | 5. Conveying Modified Source Versions. 197 | 198 | You may convey a work based on the Program, or the modifications to 199 | produce it from the Program, in the form of source code under the 200 | terms of section 4, provided that you also meet all of these conditions: 201 | 202 | a) The work must carry prominent notices stating that you modified 203 | it, and giving a relevant date. 204 | 205 | b) The work must carry prominent notices stating that it is 206 | released under this License and any conditions added under section 207 | 7. This requirement modifies the requirement in section 4 to 208 | "keep intact all notices". 209 | 210 | c) You must license the entire work, as a whole, under this 211 | License to anyone who comes into possession of a copy. This 212 | License will therefore apply, along with any applicable section 7 213 | additional terms, to the whole of the work, and all its parts, 214 | regardless of how they are packaged. This License gives no 215 | permission to license the work in any other way, but it does not 216 | invalidate such permission if you have separately received it. 217 | 218 | d) If the work has interactive user interfaces, each must display 219 | Appropriate Legal Notices; however, if the Program has interactive 220 | interfaces that do not display Appropriate Legal Notices, your 221 | work need not make them do so. 222 | 223 | A compilation of a covered work with other separate and independent 224 | works, which are not by their nature extensions of the covered work, 225 | and which are not combined with it such as to form a larger program, 226 | in or on a volume of a storage or distribution medium, is called an 227 | "aggregate" if the compilation and its resulting copyright are not 228 | used to limit the access or legal rights of the compilation's users 229 | beyond what the individual works permit. Inclusion of a covered work 230 | in an aggregate does not cause this License to apply to the other 231 | parts of the aggregate. 232 | 233 | 6. Conveying Non-Source Forms. 234 | 235 | You may convey a covered work in object code form under the terms 236 | of sections 4 and 5, provided that you also convey the 237 | machine-readable Corresponding Source under the terms of this License, 238 | in one of these ways: 239 | 240 | a) Convey the object code in, or embodied in, a physical product 241 | (including a physical distribution medium), accompanied by the 242 | Corresponding Source fixed on a durable physical medium 243 | customarily used for software interchange. 244 | 245 | b) Convey the object code in, or embodied in, a physical product 246 | (including a physical distribution medium), accompanied by a 247 | written offer, valid for at least three years and valid for as 248 | long as you offer spare parts or customer support for that product 249 | model, to give anyone who possesses the object code either (1) a 250 | copy of the Corresponding Source for all the software in the 251 | product that is covered by this License, on a durable physical 252 | medium customarily used for software interchange, for a price no 253 | more than your reasonable cost of physically performing this 254 | conveying of source, or (2) access to copy the 255 | Corresponding Source from a network server at no charge. 256 | 257 | c) Convey individual copies of the object code with a copy of the 258 | written offer to provide the Corresponding Source. This 259 | alternative is allowed only occasionally and noncommercially, and 260 | only if you received the object code with such an offer, in accord 261 | with subsection 6b. 262 | 263 | d) Convey the object code by offering access from a designated 264 | place (gratis or for a charge), and offer equivalent access to the 265 | Corresponding Source in the same way through the same place at no 266 | further charge. You need not require recipients to copy the 267 | Corresponding Source along with the object code. If the place to 268 | copy the object code is a network server, the Corresponding Source 269 | may be on a different server (operated by you or a third party) 270 | that supports equivalent copying facilities, provided you maintain 271 | clear directions next to the object code saying where to find the 272 | Corresponding Source. Regardless of what server hosts the 273 | Corresponding Source, you remain obligated to ensure that it is 274 | available for as long as needed to satisfy these requirements. 275 | 276 | e) Convey the object code using peer-to-peer transmission, provided 277 | you inform other peers where the object code and Corresponding 278 | Source of the work are being offered to the general public at no 279 | charge under subsection 6d. 280 | 281 | A separable portion of the object code, whose source code is excluded 282 | from the Corresponding Source as a System Library, need not be 283 | included in conveying the object code work. 284 | 285 | A "User Product" is either (1) a "consumer product", which means any 286 | tangible personal property which is normally used for personal, family, 287 | or household purposes, or (2) anything designed or sold for incorporation 288 | into a dwelling. In determining whether a product is a consumer product, 289 | doubtful cases shall be resolved in favor of coverage. For a particular 290 | product received by a particular user, "normally used" refers to a 291 | typical or common use of that class of product, regardless of the status 292 | of the particular user or of the way in which the particular user 293 | actually uses, or expects or is expected to use, the product. A product 294 | is a consumer product regardless of whether the product has substantial 295 | commercial, industrial or non-consumer uses, unless such uses represent 296 | the only significant mode of use of the product. 297 | 298 | "Installation Information" for a User Product means any methods, 299 | procedures, authorization keys, or other information required to install 300 | and execute modified versions of a covered work in that User Product from 301 | a modified version of its Corresponding Source. The information must 302 | suffice to ensure that the continued functioning of the modified object 303 | code is in no case prevented or interfered with solely because 304 | modification has been made. 305 | 306 | If you convey an object code work under this section in, or with, or 307 | specifically for use in, a User Product, and the conveying occurs as 308 | part of a transaction in which the right of possession and use of the 309 | User Product is transferred to the recipient in perpetuity or for a 310 | fixed term (regardless of how the transaction is characterized), the 311 | Corresponding Source conveyed under this section must be accompanied 312 | by the Installation Information. But this requirement does not apply 313 | if neither you nor any third party retains the ability to install 314 | modified object code on the User Product (for example, the work has 315 | been installed in ROM). 316 | 317 | The requirement to provide Installation Information does not include a 318 | requirement to continue to provide support service, warranty, or updates 319 | for a work that has been modified or installed by the recipient, or for 320 | the User Product in which it has been modified or installed. Access to a 321 | network may be denied when the modification itself materially and 322 | adversely affects the operation of the network or violates the rules and 323 | protocols for communication across the network. 324 | 325 | Corresponding Source conveyed, and Installation Information provided, 326 | in accord with this section must be in a format that is publicly 327 | documented (and with an implementation available to the public in 328 | source code form), and must require no special password or key for 329 | unpacking, reading or copying. 330 | 331 | 7. Additional Terms. 332 | 333 | "Additional permissions" are terms that supplement the terms of this 334 | License by making exceptions from one or more of its conditions. 335 | Additional permissions that are applicable to the entire Program shall 336 | be treated as though they were included in this License, to the extent 337 | that they are valid under applicable law. If additional permissions 338 | apply only to part of the Program, that part may be used separately 339 | under those permissions, but the entire Program remains governed by 340 | this License without regard to the additional permissions. 341 | 342 | When you convey a copy of a covered work, you may at your option 343 | remove any additional permissions from that copy, or from any part of 344 | it. (Additional permissions may be written to require their own 345 | removal in certain cases when you modify the work.) You may place 346 | additional permissions on material, added by you to a covered work, 347 | for which you have or can give appropriate copyright permission. 348 | 349 | Notwithstanding any other provision of this License, for material you 350 | add to a covered work, you may (if authorized by the copyright holders of 351 | that material) supplement the terms of this License with terms: 352 | 353 | a) Disclaiming warranty or limiting liability differently from the 354 | terms of sections 15 and 16 of this License; or 355 | 356 | b) Requiring preservation of specified reasonable legal notices or 357 | author attributions in that material or in the Appropriate Legal 358 | Notices displayed by works containing it; or 359 | 360 | c) Prohibiting misrepresentation of the origin of that material, or 361 | requiring that modified versions of such material be marked in 362 | reasonable ways as different from the original version; or 363 | 364 | d) Limiting the use for publicity purposes of names of licensors or 365 | authors of the material; or 366 | 367 | e) Declining to grant rights under trademark law for use of some 368 | trade names, trademarks, or service marks; or 369 | 370 | f) Requiring indemnification of licensors and authors of that 371 | material by anyone who conveys the material (or modified versions of 372 | it) with contractual assumptions of liability to the recipient, for 373 | any liability that these contractual assumptions directly impose on 374 | those licensors and authors. 375 | 376 | All other non-permissive additional terms are considered "further 377 | restrictions" within the meaning of section 10. If the Program as you 378 | received it, or any part of it, contains a notice stating that it is 379 | governed by this License along with a term that is a further 380 | restriction, you may remove that term. If a license document contains 381 | a further restriction but permits relicensing or conveying under this 382 | License, you may add to a covered work material governed by the terms 383 | of that license document, provided that the further restriction does 384 | not survive such relicensing or conveying. 385 | 386 | If you add terms to a covered work in accord with this section, you 387 | must place, in the relevant source files, a statement of the 388 | additional terms that apply to those files, or a notice indicating 389 | where to find the applicable terms. 390 | 391 | Additional terms, permissive or non-permissive, may be stated in the 392 | form of a separately written license, or stated as exceptions; 393 | the above requirements apply either way. 394 | 395 | 8. Termination. 396 | 397 | You may not propagate or modify a covered work except as expressly 398 | provided under this License. Any attempt otherwise to propagate or 399 | modify it is void, and will automatically terminate your rights under 400 | this License (including any patent licenses granted under the third 401 | paragraph of section 11). 402 | 403 | However, if you cease all violation of this License, then your 404 | license from a particular copyright holder is reinstated (a) 405 | provisionally, unless and until the copyright holder explicitly and 406 | finally terminates your license, and (b) permanently, if the copyright 407 | holder fails to notify you of the violation by some reasonable means 408 | prior to 60 days after the cessation. 409 | 410 | Moreover, your license from a particular copyright holder is 411 | reinstated permanently if the copyright holder notifies you of the 412 | violation by some reasonable means, this is the first time you have 413 | received notice of violation of this License (for any work) from that 414 | copyright holder, and you cure the violation prior to 30 days after 415 | your receipt of the notice. 416 | 417 | Termination of your rights under this section does not terminate the 418 | licenses of parties who have received copies or rights from you under 419 | this License. If your rights have been terminated and not permanently 420 | reinstated, you do not qualify to receive new licenses for the same 421 | material under section 10. 422 | 423 | 9. Acceptance Not Required for Having Copies. 424 | 425 | You are not required to accept this License in order to receive or 426 | run a copy of the Program. Ancillary propagation of a covered work 427 | occurring solely as a consequence of using peer-to-peer transmission 428 | to receive a copy likewise does not require acceptance. However, 429 | nothing other than this License grants you permission to propagate or 430 | modify any covered work. These actions infringe copyright if you do 431 | not accept this License. Therefore, by modifying or propagating a 432 | covered work, you indicate your acceptance of this License to do so. 433 | 434 | 10. Automatic Licensing of Downstream Recipients. 435 | 436 | Each time you convey a covered work, the recipient automatically 437 | receives a license from the original licensors, to run, modify and 438 | propagate that work, subject to this License. You are not responsible 439 | for enforcing compliance by third parties with this License. 440 | 441 | An "entity transaction" is a transaction transferring control of an 442 | organization, or substantially all assets of one, or subdividing an 443 | organization, or merging organizations. If propagation of a covered 444 | work results from an entity transaction, each party to that 445 | transaction who receives a copy of the work also receives whatever 446 | licenses to the work the party's predecessor in interest had or could 447 | give under the previous paragraph, plus a right to possession of the 448 | Corresponding Source of the work from the predecessor in interest, if 449 | the predecessor has it or can get it with reasonable efforts. 450 | 451 | You may not impose any further restrictions on the exercise of the 452 | rights granted or affirmed under this License. For example, you may 453 | not impose a license fee, royalty, or other charge for exercise of 454 | rights granted under this License, and you may not initiate litigation 455 | (including a cross-claim or counterclaim in a lawsuit) alleging that 456 | any patent claim is infringed by making, using, selling, offering for 457 | sale, or importing the Program or any portion of it. 458 | 459 | 11. Patents. 460 | 461 | A "contributor" is a copyright holder who authorizes use under this 462 | License of the Program or a work on which the Program is based. The 463 | work thus licensed is called the contributor's "contributor version". 464 | 465 | A contributor's "essential patent claims" are all patent claims 466 | owned or controlled by the contributor, whether already acquired or 467 | hereafter acquired, that would be infringed by some manner, permitted 468 | by this License, of making, using, or selling its contributor version, 469 | but do not include claims that would be infringed only as a 470 | consequence of further modification of the contributor version. For 471 | purposes of this definition, "control" includes the right to grant 472 | patent sublicenses in a manner consistent with the requirements of 473 | this License. 474 | 475 | Each contributor grants you a non-exclusive, worldwide, royalty-free 476 | patent license under the contributor's essential patent claims, to 477 | make, use, sell, offer for sale, import and otherwise run, modify and 478 | propagate the contents of its contributor version. 479 | 480 | In the following three paragraphs, a "patent license" is any express 481 | agreement or commitment, however denominated, not to enforce a patent 482 | (such as an express permission to practice a patent or covenant not to 483 | sue for patent infringement). To "grant" such a patent license to a 484 | party means to make such an agreement or commitment not to enforce a 485 | patent against the party. 486 | 487 | If you convey a covered work, knowingly relying on a patent license, 488 | and the Corresponding Source of the work is not available for anyone 489 | to copy, free of charge and under the terms of this License, through a 490 | publicly available network server or other readily accessible means, 491 | then you must either (1) cause the Corresponding Source to be so 492 | available, or (2) arrange to deprive yourself of the benefit of the 493 | patent license for this particular work, or (3) arrange, in a manner 494 | consistent with the requirements of this License, to extend the patent 495 | license to downstream recipients. "Knowingly relying" means you have 496 | actual knowledge that, but for the patent license, your conveying the 497 | covered work in a country, or your recipient's use of the covered work 498 | in a country, would infringe one or more identifiable patents in that 499 | country that you have reason to believe are valid. 500 | 501 | If, pursuant to or in connection with a single transaction or 502 | arrangement, you convey, or propagate by procuring conveyance of, a 503 | covered work, and grant a patent license to some of the parties 504 | receiving the covered work authorizing them to use, propagate, modify 505 | or convey a specific copy of the covered work, then the patent license 506 | you grant is automatically extended to all recipients of the covered 507 | work and works based on it. 508 | 509 | A patent license is "discriminatory" if it does not include within 510 | the scope of its coverage, prohibits the exercise of, or is 511 | conditioned on the non-exercise of one or more of the rights that are 512 | specifically granted under this License. You may not convey a covered 513 | work if you are a party to an arrangement with a third party that is 514 | in the business of distributing software, under which you make payment 515 | to the third party based on the extent of your activity of conveying 516 | the work, and under which the third party grants, to any of the 517 | parties who would receive the covered work from you, a discriminatory 518 | patent license (a) in connection with copies of the covered work 519 | conveyed by you (or copies made from those copies), or (b) primarily 520 | for and in connection with specific products or compilations that 521 | contain the covered work, unless you entered into that arrangement, 522 | or that patent license was granted, prior to 28 March 2007. 523 | 524 | Nothing in this License shall be construed as excluding or limiting 525 | any implied license or other defenses to infringement that may 526 | otherwise be available to you under applicable patent law. 527 | 528 | 12. No Surrender of Others' Freedom. 529 | 530 | If conditions are imposed on you (whether by court order, agreement or 531 | otherwise) that contradict the conditions of this License, they do not 532 | excuse you from the conditions of this License. If you cannot convey a 533 | covered work so as to satisfy simultaneously your obligations under this 534 | License and any other pertinent obligations, then as a consequence you may 535 | not convey it at all. For example, if you agree to terms that obligate you 536 | to collect a royalty for further conveying from those to whom you convey 537 | the Program, the only way you could satisfy both those terms and this 538 | License would be to refrain entirely from conveying the Program. 539 | 540 | 13. Remote Network Interaction; Use with the GNU General Public License. 541 | 542 | Notwithstanding any other provision of this License, if you modify the 543 | Program, your modified version must prominently offer all users 544 | interacting with it remotely through a computer network (if your version 545 | supports such interaction) an opportunity to receive the Corresponding 546 | Source of your version by providing access to the Corresponding Source 547 | from a network server at no charge, through some standard or customary 548 | means of facilitating copying of software. This Corresponding Source 549 | shall include the Corresponding Source for any work covered by version 3 550 | of the GNU General Public License that is incorporated pursuant to the 551 | following paragraph. 552 | 553 | Notwithstanding any other provision of this License, you have 554 | permission to link or combine any covered work with a work licensed 555 | under version 3 of the GNU General Public License into a single 556 | combined work, and to convey the resulting work. The terms of this 557 | License will continue to apply to the part which is the covered work, 558 | but the work with which it is combined will remain governed by version 559 | 3 of the GNU General Public License. 560 | 561 | 14. Revised Versions of this License. 562 | 563 | The Free Software Foundation may publish revised and/or new versions of 564 | the GNU Affero General Public License from time to time. Such new versions 565 | will be similar in spirit to the present version, but may differ in detail to 566 | address new problems or concerns. 567 | 568 | Each version is given a distinguishing version number. If the 569 | Program specifies that a certain numbered version of the GNU Affero General 570 | Public License "or any later version" applies to it, you have the 571 | option of following the terms and conditions either of that numbered 572 | version or of any later version published by the Free Software 573 | Foundation. If the Program does not specify a version number of the 574 | GNU Affero General Public License, you may choose any version ever published 575 | by the Free Software Foundation. 576 | 577 | If the Program specifies that a proxy can decide which future 578 | versions of the GNU Affero General Public License can be used, that proxy's 579 | public statement of acceptance of a version permanently authorizes you 580 | to choose that version for the Program. 581 | 582 | Later license versions may give you additional or different 583 | permissions. However, no additional obligations are imposed on any 584 | author or copyright holder as a result of your choosing to follow a 585 | later version. 586 | 587 | 15. Disclaimer of Warranty. 588 | 589 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY 590 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT 591 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY 592 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 593 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 594 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM 595 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF 596 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 597 | 598 | 16. Limitation of Liability. 599 | 600 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 601 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 602 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY 603 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 604 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF 605 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD 606 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 607 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 608 | SUCH DAMAGES. 609 | 610 | 17. Interpretation of Sections 15 and 16. 611 | 612 | If the disclaimer of warranty and limitation of liability provided 613 | above cannot be given local legal effect according to their terms, 614 | reviewing courts shall apply local law that most closely approximates 615 | an absolute waiver of all civil liability in connection with the 616 | Program, unless a warranty or assumption of liability accompanies a 617 | copy of the Program in return for a fee. 618 | 619 | END OF TERMS AND CONDITIONS 620 | 621 | How to Apply These Terms to Your New Programs 622 | 623 | If you develop a new program, and you want it to be of the greatest 624 | possible use to the public, the best way to achieve this is to make it 625 | free software which everyone can redistribute and change under these terms. 626 | 627 | To do so, attach the following notices to the program. It is safest 628 | to attach them to the start of each source file to most effectively 629 | state the exclusion of warranty; and each file should have at least 630 | the "copyright" line and a pointer to where the full notice is found. 631 | 632 | 633 | Copyright (C) 634 | 635 | This program is free software: you can redistribute it and/or modify 636 | it under the terms of the GNU Affero General Public License as published 637 | by the Free Software Foundation, either version 3 of the License, or 638 | (at your option) any later version. 639 | 640 | This program is distributed in the hope that it will be useful, 641 | but WITHOUT ANY WARRANTY; without even the implied warranty of 642 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 643 | GNU Affero General Public License for more details. 644 | 645 | You should have received a copy of the GNU Affero General Public License 646 | along with this program. If not, see . 647 | 648 | Also add information on how to contact you by electronic and paper mail. 649 | 650 | If your software can interact with users remotely through a computer 651 | network, you should also make sure that it provides a way for users to 652 | get its source. For example, if your program is a web application, its 653 | interface could display a "Source" link that leads users to an archive 654 | of the code. There are many ways you could offer source, and different 655 | solutions will be better for different programs; see section 13 for the 656 | specific requirements. 657 | 658 | You should also get your employer (if you work as a programmer) or school, 659 | if any, to sign a "copyright disclaimer" for the program, if necessary. 660 | For more information on this, and how to apply and follow the GNU AGPL, see 661 | . 662 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Tutorial Women Who Go POA 2 | 3 | Seja bem-vinda ao tutorial do Women Who Go Porto Alegre! 4 | 5 | O objetivo deste tutorial é mostrar que programação não é uma coisa de outro mundo e pode ser muito divertido. Nosso objetivo é construir um jogo do zero, utilizando a linguagem de programação Go. 6 | 7 | As linguagens de programação são a forma como nós nos comunicamos com os computadores e dizemos para eles o que queremos que eles façam. Além do Go existem inúmeras outras linguagens, cada uma com as suas particularidades. 8 | 9 | Assim como uma língua humana, você não precisa saber tudo de uma linguagem de programação para usá-la. Com o tempo você vai aprender recursos mais avançados e formas diferentes de escrever a mesma coisa, algumas melhores, outras piores, ou ainda, apenas diferentes. 10 | 11 | Neste tutorial faremos o possível para explicar os principais elementos da linguagem Go, porém não se sinta mal se não entender tudo neste primeiro contato. O mais importante é entender a idéia geral e é claro, se você estiver participando de um evento presencial, não hesite em pedir ajuda para as nossas *coaches*! :) 12 | 13 | ## Passo 01: Preparar o ambiente 14 | 15 | No primeiro passo nós vamos preparar o ambiente de desenvolvimento e criar um primeiro programa executável para testar se tudo está funcionando corretamente. 16 | 17 | Você vai precisar de: 18 | - Um computador com acesso à internet 19 | 20 | Você vai terminar esta etapa com: 21 | - Uma instalação do Go funcionando 22 | - Um editor de texto simples com o qual você se sinta confortável 23 | - Um programa em Go que escreve "Hello Go!" na tela 24 | 25 | Nota: para programação nós não utilizamos editores que formatam texto (por exemplo, Microsoft Word), nós usamos os editores de texto simples (em inglês *plain-text*). 26 | 27 | Sugestões de editores de texto: 28 | - MacOS: atom 29 | - Linux: gedit 30 | - Windows: Notepad++ 31 | 32 | ### Instalação do Go 33 | 34 | #### Instalação MacOS 35 | 36 | Temos duas opções de como instalar o Go no MacOS: usando Homebrew ou o instalador de pacotes do MacOS. 37 | 38 | ##### Instalando Homebrew (Opcional) 39 | 40 | O jeito mais simples de instalar o Go é usando o [Homebrew](https://brew.sh/), que é um gerenciador de pacotes para o MacOS. Para instalar o Homebrew basta rodar o seguinte comando no terminal: 41 | 42 | ``` 43 | /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" 44 | ``` 45 | 46 | O próprio script de intalação do Homebrew explica o que esta fazendo e pausa quando necessário. 47 | 48 | ##### Instalando Go 49 | 50 | Caso você tenha instalado o Homebrew, basta rodar: 51 | 52 | ``` 53 | brew install go 54 | ``` 55 | 56 | Caso você tenha optado pelo instalador de pacotes do MacOS, abra a [página de downloads](https://golang.org/dl/) do Go procure pelo arquivo do instalador para MacOS e clique no link. Os arquivos serão instalados por padrão em `/usr/local/go`. 57 | 58 | Em ambos os casos, após a instalação a sua variável de ambiente `PATH` já deve conter o binário do go. Para que o comando possa ser utilizado é possível que você tenha que reiniciar as sessões do terminal que estão abertas. 59 | 60 | Para garantir que a instalação foi bem sucedida e que o Go foi instalado corretamente, basta rodar o comando `go version` e observar uma saída parecida com a seguinte: 61 | 62 | ``` 63 | ❯ go version 64 | go version go1.8.1 darwin/amd64 65 | ``` 66 | 67 | #### Instalação Linux 68 | 69 | ##### Instalando Go 70 | 71 | Se você usa uma distribuição do Linux baseada no Debian, como o Ubuntu, basta rodar o seguinte comando: 72 | 73 | ``` 74 | sudo apt-get install golang-1.8-go 75 | ``` 76 | 77 | Para outras distribuições de linux o primeiro passo para instalar o Go é baixar o arquivo .tar.gz, para isso abra a [página de downloads](https://golang.org/dl/) do Go procure pelo link correto. 78 | 79 | Em seguida será necessário extrair o conteúdo do arquivo baixado em `/usr/local`, para criar uma árvore dos arquivos do Go em `/usr/local/go`. 80 | 81 | ``` 82 | sudo tar -C /usr/local -xzf go$VERSION.$OS-$ARCH.tar.gz 83 | ``` 84 | 85 | Por exemplo, se você baixou o arquivo `go1.8.1.linux-amd64.tar.gz`: 86 | ``` 87 | sudo tar -C /usr/local -xzf go1.8.1.linux-amd64.tar.gz 88 | ``` 89 | 90 | Finalmente, tanto para a instalação com `apt-get` quanto com o arquivo .tar.gz é necessário adicionar o binário do Go à sua variável de ambiente `PATH`. Para fazer isso adicione ao bash profile `$HOME/.profile` a linha seguinte: 91 | 92 | ``` 93 | export PATH=$PATH:/usr/local/go/bin 94 | ``` 95 | 96 | Para que o comando possa ser utilizado é possível que você tenha que reiniciar as sessões do terminal que estão abertas. 97 | 98 | Para garantir que a instalação foi bem sucedida e que o Go foi instalado corretamente, basta rodar o comando `go version` e observar uma saída parecida com a seguinte: 99 | 100 | ``` 101 | ubuntu@svartir-sandar:~$ go version 102 | go version go1.8.1 linux/amd64 103 | ``` 104 | 105 | #### Instalação Windows 106 | 107 | ##### Instalando Git 108 | 109 | O primeiro passo é instalar o Git. O jeito mais fácil é fazer o download do [Git For Windows](https://git-for-windows.github.io/). A vantagem de utilizar o Git For Windows é que também será instalado o Git Bash. No caso desse tutorial, faremos os personagens do jogo usando caracteres Unicode. Infelizmente, o prompt de comando do Windows não consegue exibir os caracteres Unicode, então para esse tutorial usaremos o Git Bash que suporta esses caracteres. 110 | 111 | Para instalar o Git For Windows basta clicar no link acima e então em Download. Siga os passos da instalação normalmente até chegar na tela de seleção de componentes. Nessa tela é muito importante selecionar a opção "Use a TrueType font in all console windows". É essa opção que vai fazer com que os caracteres Unicode sejam exibidos corretamente. 112 | 113 | ![Tela de seleção de componentes do instalador do Git For Windows.](./img/git_bash_setup_unicode.png) 114 | 115 | Continue seguindo as instruções de instalação até a tela de configuração do emulador de terminal que será utilizado pelo Git Bash. Nessa tela selecione a opção "Use MinTTY (the default terminal of MSYS2)". Juntamente com a opção selecionada anteriormente, essa opção também garantirá a exibição correta dos carcteres Unicode. 116 | 117 | ![Tela de seleção do emulador de terminal do instalador do Git For Windows.](./img/git_bash_setup_unicode_2.png) 118 | 119 | Após essa tela continue seguindo as instruções do instalador até que o Git For Windows seja instalado. Ao fim da instalação abra o Git Bash. 120 | 121 | ##### Instalando Go 122 | 123 | O jeito mais simples de instalar o Go no Windows é utilizar o instalador MSI. Na [página de downloads](https://golang.org/dl/) do Go procure pelo arquivo do instalador para Windows e clique no link. Os arquivos serão instalados por padrão em `C:\Go`. 124 | 125 | Após a instalação a sua variável de ambiente `PATH` já deve conter o binário do go (`C:\Go\bin`). Para que o comando possa ser utilizado é possível que você tenha que reiniciar o Git Bash que está aberto. 126 | 127 | Para garantir que a instalação foi bem sucedida e que o Go foi instalado corretamente, basta rodar o comando `go version` e observar uma saída parecida com a seguinte: 128 | 129 | ``` 130 | C:\Users\Camila\Documents\GitHub> go version 131 | go version go1.8.1 windows/amd64 132 | ``` 133 | 134 | ### Configurando o Workspace do Go 135 | 136 | A linguagem Go necessita que todo o código Go esteja localizado em um único workspace. O workspace é uma pasta que contém três sub-pastas: uma pasta `src`, que contém todos os arquivos fonte em Go. Uma pasta `pkg`, que contém os objetos dos pacotes e uma pasta `bin` que contém os comandos executáveis. Para mais detalhes leia a [documentação](https://golang.org/doc/code.html#Workspaces) da linguagem. 137 | 138 | A localização do workspace é definido por uma varável de ambiente chamada `GOPATH`. A localização padrão dessa variável é `%USERPROFILE%\go` (geralmente C:\Users\SeuNome\go) no Windows ou `$HOME/go` no caso do MacOS e Linux. Nesse tutorial usaremos a localização padrão do workspace. Caso você deseje utilizar outro local será necessário alterar o valor do `GOPATH` para que seu programa funcione corretamente. 139 | 140 | Para criar o workspace na localização padrão vá até a pasta home e crie a pasta `go`. Dentre as três sub-pastas do workspace, apenas a pasta `src` precisa ser criada: 141 | 142 | #### MacOS / Linux / Windows (usando Git Bash) 143 | ``` 144 | cd ~ 145 | mkdir go 146 | cd go 147 | mkdir src 148 | cd src 149 | ``` 150 | 151 | #### Windows (usando linha de comando do Windows) 152 | ``` 153 | cd %USERPROFILE% 154 | mkdir go 155 | cd go 156 | mkdir src 157 | cd src 158 | ``` 159 | 160 | Pronto! É dentro desta pasta `src` onde você pode começar a construir seu primeiro programa em Go :) 161 | 162 | ### Meu primeiro programa 163 | 164 | Existe uma tradição na área da computação em que toda vez que você vai começar a aprender uma linguagem nova você comece escrevendo um programa chamado "Hello world". 165 | 166 | Nós costumamos fazer isso porque geralmente é bem simples de fazer e nos ajuda a testar se a instalação da linguagem está ok. 167 | 168 | Então vamos fazer o mesmo para a linguagem Go. 169 | 170 | **_Coach_: explicar resumidamente o que é terminal e pasta, se necessário.** 171 | 172 | Primeiro, crie uma pasta no seu computador onde você vai guardar os códigos que escrever. Você pode dar qualquer nome para ela, mas de preferência sem acentos ou espaços. Por exemplo: `tutorial`. 173 | 174 | Digite no terminal: 175 | 176 | ``` 177 | mkdir tutorial 178 | cd tutorial 179 | ``` 180 | 181 | Abra um editor de texto simples e copie e cole o trecho a seguir: 182 | 183 | ``` 184 | package main 185 | 186 | import "fmt" 187 | 188 | func main() { 189 | fmt.Println("Olá Go!") 190 | } 191 | ``` 192 | 193 | Salve o arquivo como `main.go` na pasta que você criou para os seus códigos. 194 | 195 | Vamos **compilar** o programa. Este termo pode parecer estranho, mas na verdade isso só quer dizer que vamos traduzir o texto que escrevemos na linguagem de programação para uma linguagem que o computador entende (chamada linguagem de máquina). 196 | 197 | Para fazer isso, digite no terminal: 198 | 199 | ``` 200 | go build 201 | ``` 202 | 203 | Com este comando o Go vai "construir" o programa a partir do texto que você escreveu no arquivo `main.go`. Ele vai criar um novo arquivo na mesma pasta que é o chamado "executável". 204 | 205 | Vamos rodar este programa. Se você estiver no MacOS ou Linux, o comando para executar é assim: 206 | 207 | ``` 208 | ./tutorial 209 | ``` 210 | 211 | No Windows, o comando para executar é assim: 212 | 213 | ``` 214 | tutorial.exe 215 | ``` 216 | 217 | Você deve ter visto a mensagem "Olá Go!" sendo impressa na tela. Estamos prontas para começar! 218 | 219 | ## Passo 02: Estrutura de um jogo 220 | 221 | Neste tutorial nós vamos construir um jogo chamado PacGo. O nome é uma brincadeira com o clássico PacMan. 222 | 223 | Para quem não conhece, o seu objetivo é controlar o PacGo por um labirinto que está repleto de fantasmas. Nos corredores do labirinto existem pastilhas que contam pontos quando o PacGo come elas. 224 | 225 | Em alguns pontos estratégicos, existem cogumelos de força que tornam o PacGo temporariamente invencível aos fantasmas (e pode comê-los também, valendo pontos). O objetivo do jogo é comer todas as pastilhas do labirinto antes de perder todas as vidas. 226 | 227 | O primeiro passo no desenvolvimento de um jogo é o chamado _game design_, que é onde estabelecemos as regras e objetivos do jogo. 228 | 229 | Como estamos emprestando a idéia do PacGo de um jogo clássico, vamos pular esta etapa e partir direto para a codificação. 230 | 231 | **_Coach_: explicar brevemente o jogo Pac Man observando os aspectos de _game design_** 232 | 233 | Digite no seu terminal o seguinte comando: 234 | 235 | ``` 236 | go get github.com/wwg-poa/tutorial 237 | ``` 238 | 239 | Ele vai baixar automaticamente para você os arquivos iniciais deste projeto. 240 | 241 | Vá para a pasta `$GOHOME/src/github.com/wwg-poa/tutorial` e abra o arquivo `main.go` no seu editor de textos. Você deve ver o código abaixo: 242 | 243 | 244 | ``` 245 | package main 246 | 247 | import "fmt" 248 | 249 | func main() { 250 | // Inicializar terminal 251 | Inicializa() 252 | defer Finaliza() 253 | 254 | // Inicializar labirinto 255 | 256 | // Loop principal 257 | for { 258 | // Desenha tela 259 | 260 | // Processa entrada do jogador 261 | 262 | // Processa movimento dos fantasmas 263 | 264 | // Processa colisões 265 | 266 | // Dorme 267 | 268 | fmt.Println("Olá Go!") 269 | break // Temporário: quebra o loop infinito 270 | } 271 | } 272 | ``` 273 | 274 | Salve o arquivo. (Lembre-se sempre de salvar o arquivo após cada alteração!) 275 | 276 | **_Coach_: explicar o que são comentários, a função `main` e o que é um _loop_.** 277 | 278 | Note que o nosso programa não faz nada diferente do programa anterior. Porém, nós incluimos alguns comentários com o objetivo de preparar o terreno para as próximas etapas e um _loop_ `for` para ser o nosso _loop_ principal do jogo. 279 | 280 | Além disso, logo no começo a função `main` incluímos as chamadas para as funções `Inicializa` e `Finaliza`. O objetivo destas funções é preparar o terminal para que ele entenda corretamente as instruções de impressão e os comandos do teclado, e restaurar ele para o modo anterior quando acabarmos (a palavra chave `defer` diz para o Go executar a função `Finaliza` por último). 281 | 282 | O código que faz isto é este aqui: 283 | 284 | ``` 285 | // Inicializar terminal 286 | Inicializa() 287 | defer Finaliza() // executa no final da função 288 | ``` 289 | 290 | Note que não definimos estas funções neste arquivo, elas foram definidas para você no arquivo `utils.go`. O entendimento destas funções não é necessário para este tutorial, mas caso fique curiosa fique a vontade para explorar este arquivo. 291 | 292 | Resumidamente, para fazer um jogo nós precisamos nos preocupar com os seguintes detalhes: 293 | 294 | - Preparar os recursos do computador (tela, teclado, etc) 295 | - Carregar os dados do jogo (no caso, o mapa e a posição de cada elemento no mapa) 296 | - Criar um _loop_ principal (pois nós queremos que o jogo continue sempre funcionado até decidirmos que ele deve parar) 297 | - Dentro do _loop_: 298 | - Desenhar o labirinto na tela 299 | - Processar o movimento do jogador (também chamado de entrada do usuário) 300 | - Processar o movimento dos fantasmas 301 | - Processar colisões, o que quer dizer, verificar se o jogador bateu em algum fantasma 302 | 303 | **_Coach_: explicar o papel de cada uma dessas etapas para a construção do jogo.** 304 | 305 | Todos estes passos estão anotados no código do programa por meio dos comentários. 306 | 307 | Digite no terminal o comando `go build` para criar o programa `pacgo`. Você pode executar o programa que acabou de criar com o comando `./pacgo` (em Linux ou MacOS), ou com o comando `pacgo` (em Windows). 308 | 309 | Ao executar o `pacgo` você vai reparar que o programa parece ter **travado** o terminal, porém este é o *loop* infinito do jogo. Para sair do programa, você pode pressionar as teclas *control* (`Ctrl`) e a letra `C` simultaneamente (escrevemos `Ctrl+C` para abreviar). Lembre-se deste atalho, vamos usá-lo muitas vezes ao longo do tutorial. 310 | 311 | ## Passo 03: Construindo um labirinto 312 | 313 | A nossa primeira tarefa de codificação vai ser desenhar um labirinto na tela. 314 | 315 | **_Coach_: explique em poucas palavras o que é um _import_ e o que são bibliotecas.** 316 | 317 | Nós vamos criar uma representação do labirinto no programa. Para isso vamos utilizar uma `struct`. As _structs_ são a nossa forma de dizer que uma coisa possui várias partes, ou "propriedades". No caso, o nosso labirinto possui uma `largura`, uma `altura` e um `mapa`. 318 | 319 | No arquivo `main.go` adicione o seguinte código abaixo de `import "fmt"`: 320 | 321 | ``` 322 | type Labirinto struct { 323 | largura int 324 | altura int 325 | mapa []string 326 | } 327 | 328 | var labirinto Labirinto 329 | ``` 330 | 331 | **_Coach_: explicar a diferença entre declaração e definição.** 332 | 333 | Vamos criar as funções para construir o labirinto e desenhá-lo na tela. Coloque o código abaixo após a linha `var labirinto Labirinto`: 334 | 335 | ``` 336 | func inicializarLabirinto() { 337 | labirinto = Labirinto{ 338 | largura: 20, 339 | altura : 10, 340 | mapa : []string{ 341 | "####################", 342 | "# F#", 343 | "# #", 344 | "# #", 345 | "# #", 346 | "# #", 347 | "# #", 348 | "# #", 349 | "#G #", 350 | "####################", 351 | }, 352 | } 353 | } 354 | 355 | func desenhaTela() { 356 | for _, linha := range labirinto.mapa { 357 | fmt.Println(linha) 358 | } 359 | } 360 | ``` 361 | 362 | **_Coach_: explicar a diferença entre declaração de função e chamada de função.** 363 | 364 | No mapa, o caractere `#` representa as nossas paredes. A letra `G` representa a posição inicial do nosso personagem (o PacGo) e o `F` representa a posição inicial de um fantasma. 365 | 366 | Agora altere a função `main` para incluir a chamada para a função `inicializarLabirinto` antes do _loop_ principal. Dentro do _loop_ adicione a chamada para `desenhaTela`. Finalmente, remova a linha que imprime "Olá Go!". 367 | 368 | O código da função `main`deve ficar assim: 369 | 370 | ``` 371 | func main() { 372 | // Inicializar terminal 373 | inicializa() 374 | defer finaliza() // executa apenas no fim do programa 375 | 376 | // Inicializar labirinto 377 | inicializarLabirinto() 378 | 379 | // Loop principal 380 | for { 381 | // Desenha tela 382 | desenhaTela() 383 | 384 | // Processa entrada do jogador 385 | 386 | // Processa movimento dos fantasmas 387 | 388 | // Processa colisões 389 | 390 | // Dorme 391 | 392 | break 393 | } 394 | } 395 | ``` 396 | 397 | Vamos executá-lo, mas não esqueça de compilar o programa primeiro. No terminal: 398 | 399 | ``` 400 | go build 401 | ./tutorial 402 | ``` 403 | 404 | Note que ele imprimiu o labirinto e saiu do programa. Isso é porque colocamos a palavra `break` para quebrar o _loop_ infinito. 405 | 406 | ## Passo 04: Adicionando a entrada do teclado 407 | 408 | Por enquanto nosso programa só imprime o labirinto e sai da tela. Nada muito emocionante, certo? Mas antes de começarmos a ver as animações, precisamos preparar um pouco mais o terreno e incluir uma forma do usuário interagir com o programa. Para isso precisamos que o nosso jogo reconheça os comandos do teclado. 409 | 410 | Nós estamos particularmente interessadas em 5 teclas: a tecla ESC, que vai ser usada para sair do jogo, e as setas, que vão ser usadas para controlar o PacGo. 411 | 412 | Para o computador, cada tecla pressionada no teclado tem um valor númerico especial. Nós lemos qual tecla o usuário pressinou com a função `os.Stdin.Read`. O código abaixo faz a leitura apenas das teclas que nos interessam e dá nomes mais amigáveis para elas através do tipo `Entrada`. 413 | 414 | Copie e cole o código abaixo logo após a linha 3 (`import "fmt"`): 415 | 416 | ``` 417 | import "os" 418 | 419 | type Entrada int 420 | 421 | // Possiveis entradas do usuário 422 | const ( 423 | Nada = iota 424 | ParaCima 425 | ParaBaixo 426 | ParaEsquerda 427 | ParaDireita 428 | SairDoJogo // Tecla ESC 429 | ) 430 | 431 | func leEntradaDoUsuario() Entrada { 432 | var m Entrada 433 | array := make([]byte, 10) 434 | 435 | lido, _ := os.Stdin.Read(array) 436 | 437 | if lido == 1 && array[0] == 0x1b { 438 | m = SairDoJogo; 439 | } else if lido == 3 { 440 | if array[0] == 0x1b && array[1] == '[' { 441 | switch array[2] { 442 | case 'A': m = ParaCima 443 | case 'B': m = ParaBaixo 444 | case 'C': m = ParaDireita 445 | case 'D': m = ParaEsquerda 446 | } 447 | } 448 | } 449 | return m 450 | } 451 | ``` 452 | 453 | Agora que nós sabemos quando o usuário pressionou a tecla `ESC`, podemos nos livrar do comando `break` no _loop_ principal e deixar o usuário decidir quando quer encerrar o programa. 454 | 455 | Altere o _loop_ principal para incluir a chamada para `leEntradaDoUsuario` conforme o código abaixo: 456 | 457 | ``` 458 | // Loop principal 459 | for { 460 | // Desenha tela 461 | desenhaTela() 462 | 463 | // Processa entrada do jogador 464 | m := leEntradaDoUsuario() 465 | if m == SairDoJogo { break } 466 | 467 | // Processa movimento dos fantasmas 468 | 469 | // Processa colisões 470 | 471 | // Dorme 472 | } 473 | ``` 474 | 475 | A linha `if m == SairDoJogo { break }` interrompe o jogo toda vez que você pressionar `ESC`. Experimente: 476 | 477 | ``` 478 | go build 479 | ./tutorial 480 | ``` 481 | 482 | Você vai reparar que o jogo fica parado até você pressionar a tecla `ESC` sair. Porém, você também deve ter percebido que ao pressionar qualquer outra tecla o jogo imprime novamente o mapa logo abaixo do anterior. 483 | 484 | Isto acontece porque a cada passo do _loop_ o computador fica esperando você pressionar uma tecla, parando a execução na chamada da função `leEntradaDoUsuario`. Quando a tecla chega, ele "desprende" o programa e executa novamente o _loop_, passando por `desenhaTela`. 485 | 486 | Primeiro, vamos fazer a tela ser impressa corretamente. 487 | 488 | ## Passo 05: Corrigindo a animação 489 | 490 | **_Coach_: explicar como funciona o sistema de coordenadas da tela.** 491 | 492 | Altere a função `desenhaTela()` para incluir uma chamada para `LimpaTela()` antes de imprimir o mapa: 493 | 494 | ``` 495 | func desenhaTela() { 496 | LimpaTela() // adicione esta linha 497 | for _, linha := range labirinto.mapa { 498 | fmt.Println(linha) 499 | } 500 | } 501 | ``` 502 | 503 | A função limpa tela garante que a tela remove todo o conteúdo do terminal e retorna o cursor para a posição (0, 0) para que o desenho seja feito sempre no mesmo lugar. 504 | 505 | Experimente executar o programa novamente. Lembre-se que a tecla para sair é `ESC`. 506 | 507 | Você deve reparar que agora o programa parece não responder a nenhuma tecla exceto a `ESC`... isto acontece na verdade porque nós ainda não programamos as outras teclas para fazer nada. 508 | 509 | ## Passo 06: Mover o PacGo 510 | 511 | Agora que nós temos a estrutura de animação pronta, podemos começar a pensar em mover o nosso PacGo (atualmente representado pelo `G` no mapa). 512 | 513 | Para facilitar o controle do PacGo ao longo de todo o programa, vamos primeiro criar uma estrutura para representá-lo. Cole o código antes da definição da função `leEntradaDoUsuario`: 514 | 515 | ``` 516 | type PacGo struct { 517 | posicao Posicao 518 | figura string 519 | } 520 | 521 | var pacgo PacGo 522 | 523 | func criarPacGo(posicao Posicao, figura string) { 524 | pacgo = PacGo{ 525 | posicao: posicao, 526 | figura: "G", 527 | } 528 | } 529 | ``` 530 | 531 | Agora vamos alterar a função `inicializarLabirinto` para construir o PacGo com a sua posição correta no mapa: 532 | 533 | ``` 534 | func inicializarLabirinto() { 535 | labirinto = Labirinto{ 536 | largura: 20, 537 | altura : 10, 538 | mapa : []string{ 539 | "####################", 540 | "# F#", 541 | "# #", 542 | "# #", 543 | "# #", 544 | "# #", 545 | "# #", 546 | "# #", 547 | "#G #", 548 | "####################", 549 | }, 550 | } 551 | 552 | // O código novo começa aqui 553 | for linha, linhaMapa := range labirinto.mapa { 554 | for coluna, caractere := range linhaMapa { 555 | switch( caractere ) { 556 | case 'G': { criarPacGo( Posicao{linha, coluna}, "G") } 557 | } 558 | } 559 | } 560 | } 561 | ``` 562 | 563 | Com o PacGo criado podemos movimentá-lo. Copie e cole o código abaixo depois da definição da função `desenhaTela`: 564 | 565 | ``` 566 | func moverPacGo(m Entrada) { 567 | var novaLinha = pacgo.posicao.linha 568 | var novaColuna = pacgo.posicao.coluna 569 | 570 | switch m { 571 | case ParaCima: 572 | novaLinha-- 573 | if novaLinha < 0 { 574 | novaLinha = labirinto.altura - 1 575 | } 576 | case ParaBaixo: 577 | novaLinha++ 578 | if novaLinha >= labirinto.altura { 579 | novaLinha = 0 580 | } 581 | case ParaDireita: 582 | novaColuna++ 583 | if novaColuna >= labirinto.largura { 584 | novaColuna = 0 585 | } 586 | case ParaEsquerda: 587 | novaColuna-- 588 | if novaColuna < 0 { 589 | novaColuna = labirinto.largura - 1 590 | } 591 | } 592 | 593 | conteudoDoMapa := labirinto.mapa[novaLinha][novaColuna] 594 | if conteudoDoMapa != '#' { 595 | pacgo.posicao.linha = novaLinha 596 | pacgo.posicao.coluna = novaColuna 597 | } 598 | } 599 | ``` 600 | 601 | A função `moverPacGo` recebe um sinal de movimento e tenta atualizar a posição atual do PacGo. Porém, se a nova posição cair numa parede (representada pelo caractere `#`) a função ignora o movimento. 602 | 603 | O próximo passo é alterar o programa principal para chamar esta função toda vez que alguém pressionar uma tecla. 604 | 605 | Altere o código abaixo do comentário `// Processa entrada do jogador` para o código a seguir: 606 | 607 | ``` 608 | // Processa entrada do jogador 609 | m := leEntradaDoUsuario() 610 | 611 | if m == SairDoJogo { 612 | break 613 | } else { 614 | moverPacGo(m) 615 | } 616 | ``` 617 | 618 | O último passo vai ser alterar a função `desenhaTela` para atualizar a posição do PacGo a cada passada. Modifique o código desta função para que fique igual a função abaixo: 619 | 620 | ``` 621 | func desenhaTela() { 622 | LimpaTela() 623 | 624 | // Imprime mapa 625 | for _, linha := range labirinto.mapa { 626 | for _, char := range linha { 627 | switch char { 628 | case '#': fmt.Print("#") 629 | default: fmt.Print(" ") 630 | } 631 | } 632 | fmt.Println("") 633 | } 634 | 635 | // Imprime PacGo 636 | MoveCursor(pacgo.posicao) 637 | fmt.Printf("%s", pacgo.figura) 638 | 639 | // Move cursor para fora do labirinto 640 | MoveCursor(Posicao{labirinto.altura + 2, 0}) 641 | } 642 | ``` 643 | **_Coach_: comentar o impacto das mudanças na função desenhaTela.** 644 | 645 | Compile o programa e execute-o. Você deve reparar que as setas movem o `G` na tela. Estamos fazendo progresso! 646 | 647 | Pressione `ESC` para sair. 648 | 649 | ## Passo 07: Movendo os fantasmas 650 | 651 | Agora que o nosso PacGo é capaz de se mexer está na hora de animar os fantasmas. Vamos começar definindo uma estrutura para representar os fantasmas no código. Copie e cole a definição da `struct` Fantasma após a definição da `struct` PacGo: 652 | 653 | ``` 654 | type Fantasma struct { 655 | posicao Posicao 656 | figura string 657 | } 658 | ``` 659 | 660 | Assim como para o PacGo a estrutura acima só define a "receita" para construir o fantasma. Precisamos também criar os fantasmas propriamente ditos. Como podem existir mais de um fantasma, ao invés de declarar um único objeto fantasma vamos declarar um _array_ de fantasmas. 661 | 662 | **_Coach_: explicar o que é um _array_.** 663 | 664 | Copie e cole o código abaixo da definição do PacGo: 665 | 666 | ``` 667 | var fantasmas []*Fantasma 668 | ``` 669 | 670 | Também precisamos de uma função para criar fantasmas. Copie e cole o código abaixo da função `criarPacGo`: 671 | 672 | ``` 673 | func criarFantasma(posicao Posicao, figura string) { 674 | fantasma := &Fantasma{posicao: posicao, figura: figura} 675 | fantasmas = append(fantasmas, fantasma) 676 | } 677 | ``` 678 | 679 | Precisamos alterar a função que inicializa o mapa (`inicializarLabirinto`) para chamar a função `criarFantasma` toda vez que encontrar um caractere `F`. Faça a modificação abaixo: 680 | 681 | ``` 682 | // Processa caracteres especiais 683 | for linha, linhaMapa := range labirinto.mapa { 684 | for coluna, caractere := range linhaMapa { 685 | switch( caractere ) { 686 | case 'G': { criarPacGo(Posicao{linha, coluna}, "G") } 687 | case 'F': { criarFantasma(Posicao{linha, coluna}, "F") } 688 | } 689 | } 690 | } 691 | ``` 692 | 693 | A estrutura para criar fantasmas está completa, mas ainda não temos o código que exibe eles. Para isso precisamos alterar a função `desenhaTela`: 694 | 695 | ``` 696 | // Imprime PacGo 697 | MoveCursor(pacgo.posicao) 698 | fmt.Printf("%s", pacgo.figura) 699 | 700 | // Imprime fantasmas 701 | for _, fantasma := range fantasmas { 702 | MoveCursor(fantasma.posicao) 703 | fmt.Printf("%s", fantasma.figura) 704 | } 705 | 706 | // Move cursor para fora do labirinto 707 | MoveCursor(Posicao{labirinto.altura + 2, 0}) 708 | ``` 709 | 710 | O último passo é o código que move os fantasmas. Crie a função abaixo depois da definição da função `moverPacGo`: 711 | 712 | ``` 713 | func moverFantasmas() { 714 | for _, fantasma := range fantasmas { 715 | // gera um número aleatório entre 0 e 4 (ParaDireita = 3) 716 | var direcao = rand.Intn(ParaDireita+1) 717 | 718 | var novaPosicao = fantasma.posicao 719 | 720 | // Atualiza posição testando os limites do mapa 721 | switch direcao { 722 | case ParaCima: 723 | novaPosicao.linha-- 724 | if novaPosicao.linha < 0 { novaPosicao.linha = labirinto.altura - 1 } 725 | case ParaBaixo: 726 | novaPosicao.linha++ 727 | if novaPosicao.linha > labirinto.altura - 1 { novaPosicao.linha = 0 } 728 | case ParaEsquerda: 729 | novaPosicao.coluna-- 730 | if novaPosicao.coluna < 0 { novaPosicao.coluna = labirinto.largura - 1 } 731 | case ParaDireita: 732 | novaPosicao.coluna++ 733 | if novaPosicao.coluna > labirinto.largura - 1 { novaPosicao.coluna = 0 } 734 | } 735 | 736 | // Verifica se a posição nova do mapa é válida 737 | conteudoMapa := labirinto.mapa[novaPosicao.linha][novaPosicao.coluna] 738 | if conteudoMapa != '#' { fantasma.posicao = novaPosicao } 739 | } 740 | } 741 | ``` 742 | 743 | Como nós estamos utilizando a função `rand.Intn` do pacote `rand` precisamos adicionar o respectivo `import`: 744 | 745 | ``` 746 | import "math/rand" 747 | ``` 748 | 749 | E adicione a chamada para esta função abaixo do comentário `// Processa movimento dos fantasmas` no _loop_ principal: 750 | 751 | ``` 752 | // Processa movimento dos fantasmas 753 | moverFantasmas() 754 | ``` 755 | 756 | Compile o programa e utilize as setas para mover o PacGo. Você vai reparar que o `F` que representa o nosso fantasma vai se mover toda vez que você pressionar uma tecla. 757 | 758 | Experimente adicionar mais um fantasma no mapa para ver o que acontece. 759 | 760 | ## Passo 08: Corrigindo o movimento 761 | 762 | **_Coach_: Explicar porque o movimento dos fantasmas só ocorre após pressionar uma tecla.** 763 | 764 | Você deve ter reparado na seção anterior que o nosso jogo "trava" esperando o usuário pressionar uma tecla. Num jogo de verdade é esperado que o movimento dos inimigos seja independente do movimento do jogador. Nós precisamos separar o código que lê as teclas pressionadas pelo usuário do código do _loop_ principal. 765 | 766 | **_Coach_: Explicar brevemente os conceitos de _goroutine_ e _canais_.** 767 | 768 | Para conseguir este objetivo, vamos utilizar o conceito de `goroutines` e canais (`channels`). A função de uma _goroutine_ é justamente executar um código separado do código principal. 769 | 770 | Porém, como ele vai estar separado, é preciso ter uma maneira de comunicar com o código principal (por exemplo, para informar qual tecla foi pressionada). É aí que entram os canais: são formas de comunicação entre dois códigos que estão executando em paralelo. 771 | 772 | Altere a função `leEntradaDoUsuario` para ter a seguinte forma: 773 | 774 | ``` 775 | func leEntradaDoUsuario(canal chan<- Entrada) { 776 | array := make([]byte, 10) 777 | 778 | for { 779 | lido, _ := os.Stdin.Read(array) 780 | 781 | if lido == 1 && array[0] == 0x1b { 782 | canal <- SairDoJogo 783 | } else if lido == 3 { 784 | if array[0] == 0x1b && array[1] == '[' { 785 | switch array[2] { 786 | case 'A': canal <- ParaCima 787 | case 'B': canal <- ParaBaixo 788 | case 'C': canal <- ParaDireita 789 | case 'D': canal <- ParaEsquerda 790 | } 791 | } 792 | } 793 | } 794 | } 795 | ``` 796 | 797 | Repare nas seguintes mudanças: 798 | 799 | 1) a função agora recebe um parâmetro do tipo `chan<- Entrada` e não possui retorno. 800 | 2) ao invés de gravar na variável `m`, a função grava na variável `canal` com o operador `<-` ao invés de `=` 801 | 3) todo o código está envolto por um _loop_ infinito, o que quer dizer que uma vez chamada esta função vai executar repetidamente até o término do programa 802 | 803 | Agora vamos alterar a função `main` para chamar a função `leEntradaDoUsuario` como uma _goroutine_: 804 | 805 | ``` 806 | func main() { 807 | // Inicializar terminal 808 | Inicializa() 809 | defer Finaliza() 810 | 811 | // Inicializar labirinto 812 | inicializarLabirinto() 813 | 814 | // Cria rotina para ler entradas 815 | canal := make(chan Entrada, 10) 816 | go leEntradaDoUsuario(canal) 817 | 818 | // Loop principal 819 | for { 820 | // Desenha tela 821 | desenhaTela() 822 | 823 | // Processa entrada do jogador 824 | var tecla Entrada 825 | select { 826 | case tecla = <-canal: 827 | default: 828 | } 829 | 830 | if tecla == SairDoJogo { 831 | break 832 | } else { 833 | moverPacGo(tecla) 834 | } 835 | 836 | // Processa movimento dos fantasmas 837 | moverFantasmas() 838 | 839 | // Processa colisões 840 | 841 | // Dorme 842 | } 843 | } 844 | 845 | ``` 846 | 847 | Se você compilar e executar o programa agora, vai reparar que o movimento dos fantasmas não depende mais do movimento do PacGo. Porém, temos um efeito indesejado que é a tela ficar piscando rapidamente. 848 | 849 | Isto acontece porque o jogo não está mais "travando" na entrada do usuário antes de atualizar a tela e está atualizando ela o mais rápido possível. 850 | 851 | Tipicamente, para dar a ilusão de movimento, os jogos atualizam a tela do jogador várias vezes por segundo, onde cada uma destas telas apresenta uma imagem (também chamada de quadro ou _frame_) com uma pequena diferença em relação a anterior. 852 | 853 | Se atualizarmos a tela poucas vezes por segundo a animação vai parecer travada, mas se atualizarmos rápido demais ocorre o fenômeno de _flicker_ que é o que vocês devem ter percebido agora. 854 | 855 | O nosso jogo não possui uma animação muito complexa, então é suficiente atualizar a tela 10 vezes por segundo. O truque para fazer isso é a função `dorme`. 856 | 857 | Esta função faz com que o programa fique parado pelo número de milisegundos que passarmos como parâmetro. Passando o valor de 100 milisegundos nós conseguimos fazer com que o _loop_ principal seja executado 10 vezes por segundo. 858 | 859 | 860 | Você vai precisar do _import_ `time`: 861 | 862 | ``` 863 | import "time" 864 | ``` 865 | 866 | Adicione a declaração de `dorme` antes da função `main`: 867 | 868 | ``` 869 | func dorme(milisegundos time.Duration) { 870 | time.Sleep(time.Millisecond * milisegundos) 871 | } 872 | ``` 873 | 874 | E adicione a sua chamada abaixo do comentário `// Dorme` dentro do _loop_ principal: 875 | 876 | ``` 877 | // Dorme 878 | dorme(100) 879 | ``` 880 | 881 | Teste novamente o programa. O efeito de _flicker_ deve ter sumido. 882 | 883 | ## Passo 09: Melhorar o gráfico 884 | 885 | Nós já temos toda a funcionalidade básica do jogo pronta, mas ele ainda não se parece com um jogo de verdade. Para deixar o jogo com uma cara mais amigável, vamos utilizar emojis como os nossos gráficos! 886 | 887 | Na função `inicializarLabirinto`, vamos passar o código dos emojis no lugar das letras `G` e `F`: 888 | 889 | ``` 890 | // Processa caracteres especiais 891 | for linha, linhaMapa := range labirinto.mapa { 892 | for coluna, caractere := range linhaMapa { 893 | switch( caractere ) { 894 | case 'G': { criarPacGo(Posicao{linha, coluna}, "\xF0\x9F\x98\x83") } 895 | case 'F': { criarFantasma(Posicao{linha, coluna}, "\xF0\x9F\x91\xBB") } 896 | } 897 | } 898 | } 899 | ``` 900 | 901 | Além disso, vamos substituir o símbolo `#` por paredes de verdade. Na função `desenhaTela`, altere o código abaixo para imprimir o muro: 902 | 903 | ``` 904 | // Imprime mapa 905 | for _, linha := range labirinto.mapa { 906 | for _, char := range linha { 907 | switch char { 908 | case '#': fmt.Print(FundoAzul(" ")) 909 | default: fmt.Print(" ") 910 | } 911 | } 912 | fmt.Println("") 913 | } 914 | ``` 915 | 916 | Compile e execute o programa. 917 | 918 | ## Passo 10: Adicionar pastilhas e pontos 919 | 920 | O nosso jogo está ganhando forma, mas para parecer um jogo mesmo, precisamos adicionar algumas funcionalidades. Primeiro, nós precisamos de um placar e uma forma do PacGo ganhar pontos. 921 | 922 | Vamos primeiro criar um campo para guardar os pontos na struct PacGo: 923 | 924 | ``` 925 | type PacGo struct { 926 | posicao Posicao 927 | figura string 928 | pontos int 929 | } 930 | ``` 931 | 932 | Depois vamos alterar a função `desenhaTela` para incluir a impressão do placar e as pastilhas no mapa: 933 | 934 | ``` 935 | func desenhaTela() { 936 | LimpaTela() 937 | 938 | // Imprime placar 939 | MoveCursor(Posicao{0, 0}) 940 | placar := fmt.Sprintf("Pontos: %d", pacgo.pontos) 941 | fmt.Println(Vermelho(Intenso(placar))) 942 | 943 | // Ajuste para desenhar o mapa embaixo do placar 944 | deslocamento := Posicao{2, 0} 945 | MoveCursor(deslocamento) 946 | 947 | // Imprime mapa 948 | for _, linha := range labirinto.mapa { 949 | for _, char := range linha { 950 | switch char { 951 | case '#': fmt.Print(FundoAzul(" ")) 952 | case '.': fmt.Print(".") 953 | default: fmt.Print(" ") 954 | } 955 | } 956 | fmt.Println("") 957 | } 958 | 959 | // Imprime PacGo 960 | MoveCursor(pacgo.posicao.Soma(deslocamento)) 961 | fmt.Printf("%s", pacgo.figura) 962 | 963 | // Imprime fantasmas 964 | for _, fantasma := range fantasmas { 965 | MoveCursor(fantasma.posicao.Soma(deslocamento)) 966 | fmt.Printf("%s", fantasma.figura) 967 | } 968 | 969 | // Move cursor para fora do labirinto 970 | MoveCursor(deslocamento.Soma(Posicao{labirinto.altura + 2, 0})) 971 | } 972 | ``` 973 | 974 | Finalmente, altere o código da função `moverPacGo` onde está a lógica responsável por detectar paredes para incluir a contagem de pontos: 975 | 976 | ``` 977 | conteudoDoMapa := labirinto.mapa[novaLinha][novaColuna] 978 | if conteudoDoMapa != '#' { 979 | pacgo.posicao.linha = novaLinha 980 | pacgo.posicao.coluna = novaColuna 981 | 982 | if conteudoDoMapa == '.' { 983 | pacgo.pontos += 10 984 | 985 | // Remove item do mapa 986 | linha := labirinto.mapa[novaLinha] 987 | linha = linha[:novaColuna] + " " + linha[novaColuna+1:] 988 | labirinto.mapa[novaLinha] = linha 989 | } 990 | } 991 | ``` 992 | 993 | ## Passo 11: Adicionar vidas 994 | 995 | Nós temos um placar funcionando e o nosso PacGo pode ganhar pontos, mas os fantasmas ainda não são uma ameaça. Está na hora de tornar o jogo um pouco mais difícil: vamos incluir a contagem de vidas e a possibilidade dos fantasmas matarem o PacGo. 996 | 997 | Toda vez que o PacGo morre ele deve voltar para o seu ponto de origem no mapa. Por isso, precisamos guardar a posição onde ele inicia. Vamos adicionar o número de vidas e a posicição inicial na estrutura `PacGo`: 998 | 999 | ``` 1000 | type PacGo struct { 1001 | posicao Posicao 1002 | posInicial Posicao 1003 | figura string 1004 | pontos int 1005 | vidas int 1006 | } 1007 | ``` 1008 | 1009 | Na criação do `PacGo` salvamos a posicição inicial e configuramos o número inicial de vidas: 1010 | 1011 | ``` 1012 | func criarPacGo(pos Posicao, fig string) { 1013 | pacgo = PacGo{ 1014 | posicao: pos, 1015 | posInicial: pos, 1016 | figura: fig, 1017 | vidas: 2, 1018 | } 1019 | } 1020 | ``` 1021 | 1022 | E modificamos o placar para mostrar as vidas: 1023 | 1024 | ``` 1025 | // Imprime placar 1026 | MoveCursor(Posicao{0, 0}) 1027 | placar := fmt.Sprintf("Pontos: %d Vidas: %d", pacgo.pontos, pacgo.vidas) 1028 | fmt.Println(Vermelho(Intenso(placar))) 1029 | ``` 1030 | 1031 | Agora só falta adicionar a lógica da colisão com os fantasmas. Primeiro vamos criar uma função para buscar um fantasma na posição atual do PacGo: 1032 | 1033 | ``` 1034 | func detectarColisao() *Fantasma { 1035 | for _, fantasma := range fantasmas { 1036 | if fantasma.posicao == pacgo.posicao { 1037 | return fantasma 1038 | } 1039 | } 1040 | return nil 1041 | } 1042 | ``` 1043 | 1044 | E no loop principal adicione o seguinte código para processar a colisão: 1045 | 1046 | ``` 1047 | // Processa colisões 1048 | if fantasma := detectarColisao(); fantasma != nil { 1049 | pacgo.vidas-- 1050 | if pacgo.vidas < 0 { 1051 | MoveCursor(Posicao{labirinto.altura + 3, 0}) 1052 | fmt.Print("Fim de jogo! Os fantasmas venceram... \xF0\x9F\x98\xAD\n\n") 1053 | break 1054 | } 1055 | // Reseta posição do PacGopher para a posição inicial 1056 | pacgo.posicao = pacgo.posInicial 1057 | } 1058 | ``` 1059 | 1060 | Compile o código e execute para ver o resultado! 1061 | 1062 | ## Passo 12: Vencendo o jogo 1063 | 1064 | Na etapa passada nós adicionamos o suporte a vidas, o que permite que o jogador perca o jogo caso acabem todas as suas vidas. Agora precisamos dar condições para que o jogador vença a partida. 1065 | 1066 | O jogo acaba quando o PacGo come todas as pastilhas do labirinto. Para fazer isso, nós precisamos contar quantas pastilhas temos no total e quando este número chegar a zero a partida acabou e o PacGo venceu. 1067 | 1068 | A maneira mais fácil de fazer isso é manter um contador de pastilhas na estrutura labirinto, inicializar com o total de pastilhas no momento da criação do labirinto e decrementar este número toda vez que o PacGo comer uma pastilha. 1069 | 1070 | ### Criando o contador 1071 | 1072 | Na estrutura `Labirinto`: 1073 | 1074 | ``` 1075 | type Labirinto struct { 1076 | largura int 1077 | altura int 1078 | mapa []string 1079 | muro string 1080 | numPastilhas int 1081 | } 1082 | ``` 1083 | 1084 | Na função `inicializarLabirinto`: 1085 | 1086 | ``` 1087 | // Processa caracteres especiais 1088 | for linha, linhaMapa := range labirinto.mapa { 1089 | for coluna, caractere := range linhaMapa { 1090 | switch caractere { 1091 | case 'G': 1092 | criarPacGo(Posicao{linha, coluna}, "\xF0\x9F\x98\x83") 1093 | case 'F': 1094 | criarFantasma(Posicao{linha, coluna}, "\xF0\x9F\x91\xBB") 1095 | case '.': 1096 | labirinto.numPastilhas++ 1097 | } 1098 | } 1099 | } 1100 | ``` 1101 | 1102 | ### Decrementando o contator 1103 | 1104 | Na função `moverPacGo`: 1105 | 1106 | ``` 1107 | conteudoDoMapa := labirinto.mapa[novaLinha][novaColuna] 1108 | if conteudoDoMapa != '#' { 1109 | pacgo.posicao.linha = novaLinha 1110 | pacgo.posicao.coluna = novaColuna 1111 | 1112 | if conteudoDoMapa == '.' { 1113 | pacgo.pontos += 10 1114 | labirinto.numPastilhas-- 1115 | 1116 | // Remove item do mapa 1117 | linha := labirinto.mapa[novaLinha] 1118 | linha = linha[:novaColuna] + " " + linha[novaColuna+1:] 1119 | labirinto.mapa[novaLinha] = linha 1120 | } 1121 | } 1122 | ``` 1123 | 1124 | ### Adicionando fim de jogo (vitória) 1125 | 1126 | No _loop_ principal, adicione o seguinte teste: 1127 | 1128 | ``` 1129 | // Fim de jogo 1130 | if labirinto.numPastilhas == 0 { 1131 | MoveCursor(Posicao{labirinto.altura + 3, 0}) 1132 | fmt.Print("Fim de jogo! Você venceu! \xF0\x9F\x98\x84\n\n") 1133 | break 1134 | } 1135 | ``` 1136 | 1137 | Compile e teste! :) 1138 | 1139 | ## Passo 13: Power Ups 1140 | 1141 | O nosso jogo está quase completo, mas ainda falta um recurso importante! No jogo original, o PacGo pode comer pilulas especiais que dão o poder de comer os fantasmas. O efeito desta pílula é temporárioe dura apenas alguns segundos, mas comer os fantasmas neste estado dá muitos pontos! 1142 | 1143 | Na falta de um emoji pílula nós usamos o cogumelo. (Fique a vontade para escolher qualquer [emoji](https://apps.timwhitlock.info/emoji/tables/unicode)) 1144 | 1145 | ### Adicionar variável para controlar o estado da pilula 1146 | 1147 | ``` 1148 | type PacGo struct { 1149 | posicao Posicao 1150 | posInicial Posicao 1151 | figura string 1152 | pontos int 1153 | vidas int 1154 | pilula bool 1155 | } 1156 | ``` 1157 | 1158 | ### Adicionar a detecção da pilula 1159 | 1160 | A pilula é representada pelo caractere `P` no mapa. Altere a função `moverPacGo`: 1161 | 1162 | ``` 1163 | if conteudoDoMapa != '#' { 1164 | pacgo.posicao.linha = novaLinha 1165 | pacgo.posicao.coluna = novaColuna 1166 | 1167 | if conteudoDoMapa == '.' || conteudoDoMapa == 'P' { 1168 | switch conteudoDoMapa { 1169 | case '.': 1170 | pacgo.pontos += 10 1171 | labirinto.numPastilhas-- 1172 | case 'P': 1173 | pacgo.pontos += 100 1174 | ativarPilula() 1175 | } 1176 | 1177 | // Remove item do mapa 1178 | linha := labirinto.mapa[novaLinha] 1179 | linha = linha[:novaColuna] + " " + linha[novaColuna+1:] 1180 | labirinto.mapa[novaLinha] = linha 1181 | } 1182 | } 1183 | ``` 1184 | 1185 | ### Ativar modo invencível 1186 | 1187 | Crie as funções abaixo para ativar e desativar o modo invencível: 1188 | 1189 | ``` 1190 | func ativarPilula() { 1191 | pacgo.pilula = true 1192 | go desativarPilula(10000) // 10 segundos 1193 | } 1194 | 1195 | func desativarPilula(milisegundos time.Duration) { 1196 | dorme(milisegundos) 1197 | pacgo.pilula = false 1198 | } 1199 | ``` 1200 | 1201 | ### Modificar a detecção de colisão 1202 | 1203 | ``` 1204 | // Processa colisões 1205 | if fantasma := detectarColisao(); fantasma != nil { 1206 | if pacgo.pilula { 1207 | go ressucitarFantasma(fantasma) 1208 | matarFantasma(fantasma) 1209 | pacgo.pontos += 500 1210 | } else { 1211 | pacgo.vidas-- 1212 | // Reseta posição do PacGo para a posição inicial 1213 | pacgo.posicao = pacgo.posInicial 1214 | } 1215 | 1216 | if pacgo.vidas < 0 { 1217 | MoveCursor(Posicao{labirinto.altura + 3, 0}) 1218 | fmt.Print("Fim de jogo! Os fantasmas venceram... \xF0\x9F\x98\xAD\n\n") 1219 | break 1220 | } 1221 | 1222 | } 1223 | ``` 1224 | 1225 | ### Adicionar lógica para matar os fantasmas 1226 | 1227 | ``` 1228 | func ressucitarFantasma(fantasma *Fantasma, milisegundos time.Duration) { 1229 | dorme(milisegundos) 1230 | criarFantasma(fantasma.posicao, fantasma.figura) 1231 | } 1232 | 1233 | func matarFantasma(fantasma *Fantasma) { 1234 | var indice int 1235 | for idx, f := range fantasmas { 1236 | if f.posicao == fantasma.posicao { 1237 | indice = idx 1238 | break 1239 | } 1240 | } 1241 | fantasmas = append(fantasmas[:indice], fantasmas[indice+1:]...) 1242 | } 1243 | ``` 1244 | 1245 | ### Mudar a cor do mapa durante o efeito da pilula 1246 | 1247 | Para que o jogador saiba que ainda está sobre o efeito da pílula, vamos mudar a cor do mapa durante o efeito dela. Altere a função `desenhaTela` para testar se a pílula está ativa: 1248 | 1249 | ``` 1250 | // Imprime mapa 1251 | for _, linha := range labirinto.mapa { 1252 | for _, char := range linha { 1253 | switch char { 1254 | case '#': 1255 | if pacgo.pilula { 1256 | fmt.Print(FundoVermelho(" ")) 1257 | } else { 1258 | fmt.Print(FundoAzul(" ")) 1259 | } 1260 | case '.': 1261 | fmt.Print(".") 1262 | case 'P': 1263 | fmt.Print("\xF0\x9F\x8D\x84") 1264 | default: 1265 | fmt.Print(" ") 1266 | } 1267 | } 1268 | fmt.Println("") 1269 | } 1270 | ``` 1271 | 1272 | ## Passo 14: Suporte a novos mapas 1273 | 1274 | Nosso jogo está quase completo! Vamos agora para a última etapa, que é suportar mapas externos. Para isso vamos precisar ler arquivos do disco e carregá-los em memória. 1275 | 1276 | ### Lendo o parâmetro do programa 1277 | 1278 | ``` 1279 | // Lê parâmetros do sistema operacional 1280 | args := os.Args[1:] 1281 | var arquivo string 1282 | if len(args) >= 1 { 1283 | arquivo = args[0] 1284 | } else { 1285 | arquivo = "" 1286 | } 1287 | 1288 | // Inicializar labirinto 1289 | inicializarLabirinto(arquivo) 1290 | ``` 1291 | 1292 | ### Carregando o arquivo 1293 | 1294 | Modifique a função `inicializarLabirinto` para carregar o mapa do arquivo ao invés da memória: 1295 | 1296 | ``` 1297 | func inicializarLabirinto(arquivo string) error { 1298 | var ErrMapNotFound = errors.New("Não conseguiu ler o arquivo do mapa") 1299 | 1300 | // aplica o valor default caso não seja passado um arquivo 1301 | var tmpArquivo string 1302 | tmpArquivo = arquivo 1303 | if tmpArquivo == "" { 1304 | tmpArquivo = "./mapas/mapa01.txt" 1305 | } 1306 | 1307 | // abre arquivo 1308 | file, err := os.Open(tmpArquivo) 1309 | if err != nil { 1310 | log.Fatal(err) 1311 | return ErrMapNotFound 1312 | } 1313 | // fecha depois de ler o arquivo 1314 | defer file.Close() 1315 | 1316 | // inicializa o mapa vazio 1317 | mapa := []string{} 1318 | 1319 | // cria um leitor para ler linha a linha o arquivo 1320 | scanner := bufio.NewScanner(file) 1321 | for scanner.Scan() { 1322 | linha := scanner.Text() 1323 | mapa = append(mapa, linha) 1324 | } 1325 | 1326 | // determina o tamanho do mapa baseado no arquivo lido 1327 | largura := len(mapa[0]) 1328 | altura := len(mapa) 1329 | 1330 | labirinto = Labirinto{ 1331 | largura: largura, 1332 | altura: altura, 1333 | mapa: mapa, 1334 | } 1335 | 1336 | // Processa caracteres especiais 1337 | for linha, linhaMapa := range labirinto.mapa { 1338 | for coluna, caractere := range linhaMapa { 1339 | switch caractere { 1340 | case 'G': 1341 | criarPacGo(Posicao{linha, coluna}, "\xF0\x9F\x98\x83") 1342 | case 'F': 1343 | criarFantasma(Posicao{linha, coluna}, "\xF0\x9F\x91\xBB") 1344 | case '.': 1345 | labirinto.numPastilhas++ 1346 | } 1347 | } 1348 | } 1349 | 1350 | return nil 1351 | } 1352 | ``` 1353 | 1354 | Dentro do repositório do projeto existe uma pasta `mapas` que contém alguns mapas para testar. Experimente criar o seu próprio mapa! 1355 | 1356 | ## Próximos passos 1357 | 1358 | Parabéns! Ao chegar nesta etapa você já tem um jogo completo funcionando. Mas você não precisa parar por aqui. Pense em que melhorias gostaria de ter no jogo e pesquise como implementá-las. A melhor forma de aprender é na prática, e ter um projeto _open source_ é um ótimo ponto de partida. 1359 | 1360 | Algumas sugestões de melhorias: 1361 | - Adicionar um segundo jogador 1362 | - Adicionar outros tipos de item no mapa 1363 | - Adicionar efeitos especiais (cores) 1364 | - Deixar os fantasmas mais inteligentes 1365 | 1366 | As possibilidades são infinitas! 1367 | 1368 | E é claro, divulgue o seu jogo na nossa página no Facebook [Women Who Go Brasil](https://www.facebook.com/WomenWhoGoBrasil/) e no Twitter mencionando @womenwhogo e @womenwhogo_poa. 1369 | 1370 | ## Referências 1371 | 1372 | [Tabela de emojis](https://apps.timwhitlock.info/emoji/tables/unicode) 1373 | -------------------------------------------------------------------------------- /img/git_bash_setup_unicode.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wwg-poa/pacgo/05c80f5993e96b0386b4423eabf2186ce9f84a2d/img/git_bash_setup_unicode.png -------------------------------------------------------------------------------- /img/git_bash_setup_unicode_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wwg-poa/pacgo/05c80f5993e96b0386b4423eabf2186ce9f84a2d/img/git_bash_setup_unicode_2.png -------------------------------------------------------------------------------- /legacy/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "errors" 6 | "fmt" 7 | "log" 8 | "math/rand" 9 | "os" 10 | "regexp" 11 | "time" 12 | ) 13 | 14 | // Posicao é a struct que define uma posição no mapa 15 | type Posicao struct { 16 | linha int 17 | coluna int 18 | } 19 | 20 | // PacGo é a struct que define o jogo PacGo 21 | type PacGo struct { 22 | posicao Posicao 23 | posicaoInicial Posicao 24 | figura string // emoji 25 | pilula bool 26 | vidas int 27 | pontos int 28 | invencivel bool 29 | figuras []string 30 | indiceFig int 31 | figuraBravo string 32 | contadorFig Contador 33 | } 34 | 35 | // Contador é a struct que define um contador 36 | type Contador struct { 37 | max int 38 | contador int 39 | } 40 | 41 | // Fantasma é a struct que define um fantasma 42 | type Fantasma struct { 43 | posicao Posicao 44 | figura string // emoji 45 | } 46 | 47 | // Labirinto é a struct que define o labirinto 48 | type Labirinto struct { 49 | largura int 50 | altura int 51 | mapa []string 52 | figMuro string 53 | figMuroSuper string 54 | figSP string 55 | quantiaPastilhas int 56 | } 57 | 58 | // Movimento é a variável que define o movimento no cenário 59 | type Movimento int 60 | 61 | // Possiveis entradas do usuário 62 | const ( 63 | Nada = iota 64 | ParaCima 65 | ParaBaixo 66 | ParaEsquerda 67 | ParaDireita 68 | SairDoJogo // Tecla ESC 69 | ) 70 | 71 | var labirinto *Labirinto 72 | var pacgo *PacGo 73 | var fantasmas []*Fantasma 74 | var mapaSinais map[int]string 75 | 76 | func criarFantasma(posicao Posicao, figura string) { 77 | fantasma := &Fantasma{posicao: posicao, figura: figura} 78 | fantasmas = append(fantasmas, fantasma) 79 | } 80 | 81 | func criarPacGo(posicao Posicao, figura string, pilula bool, vidas int) { 82 | pacgo = &PacGo{ 83 | posicao: posicao, 84 | posicaoInicial: posicao, 85 | figura: "\xF0\x9F\x98\x83", 86 | pilula: false, 87 | vidas: 3, 88 | figuras: []string{"\xF0\x9F\x98\x83", "\xF0\x9F\x98\x8C"}, 89 | indiceFig: 0, 90 | contadorFig: Contador{3, 0}, 91 | figuraBravo: "\xF0\x9F\x98\xA1", 92 | } 93 | } 94 | 95 | func construirLabirinto(nomeArquivo string) error { 96 | 97 | var ErrMapNotFound = errors.New("Não conseguiu ler o arquivo do mapa") 98 | 99 | var arquivo string 100 | if nomeArquivo == "" { 101 | arquivo = "./data/mapa.txt" 102 | } else { 103 | arquivo = nomeArquivo 104 | } 105 | 106 | file, err := os.Open(arquivo) 107 | if err != nil { 108 | log.Fatal(err) 109 | return ErrMapNotFound 110 | } 111 | 112 | // fecha depois de ler o arquivo 113 | defer file.Close() 114 | 115 | // inicializa o mapa vazio 116 | mapa := []string{} 117 | 118 | r, _ := regexp.Compile("[^ #.P]") 119 | 120 | // cria um leitor para ler linha a linha o arquivo 121 | scanner := bufio.NewScanner(file) 122 | quantiaPastilhas := 0 123 | for scanner.Scan() { 124 | linha := scanner.Text() 125 | 126 | for indice, caracter := range linha { 127 | switch caracter { 128 | case 'F': 129 | criarFantasma(Posicao{len(mapa), indice}, "\xF0\x9F\x91\xBB") 130 | case 'G': 131 | criarPacGo(Posicao{len(mapa), indice}, "\xF0\x9F\x98\x83", false, 3) 132 | case '.': 133 | quantiaPastilhas++ 134 | } 135 | } 136 | 137 | linha = r.ReplaceAllString(linha, " ") 138 | mapa = append(mapa, linha) 139 | } 140 | 141 | // verifica se teve erro o leitor 142 | if err = scanner.Err(); err != nil { 143 | log.Fatal(err) 144 | return ErrMapNotFound 145 | } 146 | 147 | labirinto = &Labirinto{ 148 | largura: len(mapa[0]), 149 | altura: len(mapa), 150 | mapa: mapa, 151 | figMuro: fundoAzul(" "), 152 | figMuroSuper: fundoVermelho(" "), 153 | figSP: "\xF0\x9F\x8D\x84", 154 | quantiaPastilhas: quantiaPastilhas, 155 | } 156 | return nil 157 | } 158 | 159 | func atualizarLabirinto() { 160 | tela.limpa() 161 | 162 | // Imprime os pontos 163 | tela.moveCursor(Posicao{0, 0}) 164 | pontosEVidas := fmt.Sprintf("Pontos: %d Vidas: %d", pacgo.pontos, pacgo.vidas) 165 | fmt.Println(vermelho(intenso(pontosEVidas))) 166 | 167 | posicaoInicial := Posicao{2, 0} 168 | tela.moveCursor(posicaoInicial) 169 | 170 | var muro = labirinto.figMuro 171 | if pacgo.pilula == true { 172 | muro = labirinto.figMuroSuper 173 | } 174 | 175 | for _, linha := range labirinto.mapa { 176 | for _, char := range linha { 177 | switch char { 178 | case '#': 179 | fmt.Print(muro) 180 | case '.': 181 | fmt.Print(".") 182 | case 'P': 183 | fmt.Print(labirinto.figSP) 184 | default: 185 | fmt.Print(" ") 186 | } 187 | } 188 | fmt.Println("") 189 | } 190 | 191 | // Imprime PacGo 192 | tela.moveCursor(posicaoInicial.adiciona(&pacgo.posicao)) 193 | if pacgo.pilula { 194 | fmt.Printf("%s", pacgo.figuraBravo) 195 | } else { 196 | fmt.Printf("%s", pacgo.figuras[pacgo.indiceFig]) 197 | pacgo.incrementaIndice() 198 | } 199 | 200 | // Imprime fantasmas 201 | for _, fantasma := range fantasmas { 202 | tela.moveCursor(posicaoInicial.adiciona(&fantasma.posicao)) 203 | fmt.Printf("%s", fantasma.figura) 204 | } 205 | 206 | // Move o cursor para fora do labirinto 207 | tela.moveCursor(posicaoInicial.adiciona(&Posicao{labirinto.altura + 2, 0})) 208 | } 209 | 210 | func detectarColisao() bool { 211 | for _, fantasma := range fantasmas { 212 | if fantasma.posicao == pacgo.posicao { 213 | return true 214 | } 215 | } 216 | return false 217 | } 218 | 219 | func moverPacGo(m Movimento) { 220 | var novaLinha = pacgo.posicao.linha 221 | var novaColuna = pacgo.posicao.coluna 222 | 223 | switch m { 224 | case ParaCima: 225 | novaLinha-- 226 | if novaLinha < 0 { 227 | novaLinha = labirinto.altura - 1 228 | } 229 | case ParaBaixo: 230 | novaLinha++ 231 | if novaLinha >= labirinto.altura { 232 | novaLinha = 0 233 | } 234 | case ParaDireita: 235 | novaColuna++ 236 | if novaColuna >= labirinto.largura { 237 | novaColuna = 0 238 | } 239 | case ParaEsquerda: 240 | novaColuna-- 241 | if novaColuna < 0 { 242 | novaColuna = labirinto.largura - 1 243 | } 244 | } 245 | 246 | conteudoDoMapa := labirinto.mapa[novaLinha][novaColuna] 247 | if conteudoDoMapa != '#' { 248 | pacgo.posicao.linha = novaLinha 249 | pacgo.posicao.coluna = novaColuna 250 | 251 | if (conteudoDoMapa == '.') || (conteudoDoMapa == 'P') { 252 | if conteudoDoMapa == '.' { 253 | pacgo.pontos += 10 254 | // fmt.Print("\x07") 255 | labirinto.quantiaPastilhas-- 256 | } else { 257 | pacgo.pontos += 100 258 | ativarPilula() 259 | } 260 | 261 | linha := labirinto.mapa[novaLinha] 262 | linha = linha[:novaColuna] + " " + linha[novaColuna+1:] 263 | labirinto.mapa[novaLinha] = linha 264 | } 265 | } 266 | } 267 | 268 | func moverFantasmas() { 269 | for _, fantasma := range fantasmas { 270 | // gera um número aleatório entre 0 e 4 (ParaDireita = 3) 271 | var direcao = rand.Intn(ParaDireita + 1) 272 | 273 | var novaPosicao = fantasma.posicao 274 | 275 | // Atualiza posição testando os limites do mapa 276 | switch direcao { 277 | case ParaCima: 278 | novaPosicao.linha-- 279 | if novaPosicao.linha < 0 { 280 | novaPosicao.linha = labirinto.altura - 1 281 | } 282 | case ParaBaixo: 283 | novaPosicao.linha++ 284 | if novaPosicao.linha > labirinto.altura-1 { 285 | novaPosicao.linha = 0 286 | } 287 | case ParaEsquerda: 288 | novaPosicao.coluna-- 289 | if novaPosicao.coluna < 0 { 290 | novaPosicao.coluna = labirinto.largura - 1 291 | } 292 | case ParaDireita: 293 | novaPosicao.coluna++ 294 | if novaPosicao.coluna > labirinto.largura-1 { 295 | novaPosicao.coluna = 0 296 | } 297 | } 298 | 299 | // Verifica se a posição nova do mapa é válida 300 | conteudoMapa := labirinto.mapa[novaPosicao.linha][novaPosicao.coluna] 301 | if conteudoMapa != '#' { 302 | fantasma.posicao = novaPosicao 303 | } 304 | } 305 | } 306 | 307 | func dorme(milisegundos time.Duration) { 308 | time.Sleep(time.Millisecond * milisegundos) 309 | } 310 | 311 | func entradaDoUsuario(canal chan<- Movimento) { 312 | array := make([]byte, 10) 313 | 314 | for { 315 | lido, _ := os.Stdin.Read(array) 316 | 317 | if lido == 1 && array[0] == 0x1b { 318 | canal <- SairDoJogo 319 | } else if lido == 3 { 320 | if array[0] == 0x1b && array[1] == '[' { 321 | switch array[2] { 322 | case 'A': 323 | canal <- ParaCima 324 | case 'B': 325 | canal <- ParaBaixo 326 | case 'C': 327 | canal <- ParaDireita 328 | case 'D': 329 | canal <- ParaEsquerda 330 | } 331 | } 332 | } 333 | } 334 | } 335 | 336 | func ativarPilula() { 337 | pacgo.pilula = true 338 | go desativarPilula(10000) 339 | } 340 | 341 | func desativarPilula(milisegundos time.Duration) { 342 | dorme(milisegundos) 343 | pacgo.pilula = false 344 | } 345 | 346 | func terminarJogo() { 347 | // pacgo morreu :( 348 | tela.moveCursor(Posicao{labirinto.altura + 2, 0}) 349 | fmt.Println("Fim de jogo! Os fantasmas venceram... \xF0\x9F\x98\xAD") 350 | } 351 | 352 | func main() { 353 | inicializa() 354 | defer finaliza() 355 | 356 | mapaSinais = make(map[int]string) 357 | mapaSinais[0] = "Cima" 358 | mapaSinais[1] = "Baixo" 359 | mapaSinais[2] = "Direita" 360 | mapaSinais[3] = "Esquerda" 361 | 362 | args := os.Args[1:] 363 | var arquivo string 364 | if len(args) >= 1 { 365 | arquivo = args[0] 366 | } else { 367 | arquivo = "" 368 | } 369 | 370 | construirLabirinto(arquivo) 371 | 372 | canal := make(chan Movimento, 10) 373 | 374 | // Processos assincronos 375 | go entradaDoUsuario(canal) 376 | go moverFantasmas() 377 | 378 | var tecla Movimento 379 | for { 380 | atualizarLabirinto() 381 | if labirinto.quantiaPastilhas == 0 { 382 | tela.moveCursor(Posicao{labirinto.altura + 2, 0}) 383 | fmt.Print("Fim de jogo! Você venceu! \xF0\x9F\x98\x84\n\n\n") 384 | break 385 | } 386 | 387 | // canal não-bloqueador 388 | select { 389 | case tecla = <-canal: 390 | moverPacGo(tecla) 391 | default: 392 | } 393 | if tecla == SairDoJogo { 394 | break 395 | } 396 | 397 | if detectarColisao() { 398 | if pacgo.pilula { 399 | _, f := buscaFantasma(pacgo.posicao) 400 | go criarFantasmaTemporizado(f, 5000) 401 | matarFantasma(f) 402 | pacgo.pontos = pacgo.pontos + 500 403 | } else { 404 | // pacgo perde vidas 405 | if !pacgo.invencivel { 406 | pacgo.vidas-- 407 | if pacgo.vidas < 0 { 408 | terminarJogo() 409 | break 410 | } 411 | ativarInvencibilidade(3000) 412 | pacgo.posicao.linha = pacgo.posicaoInicial.linha 413 | pacgo.posicao.coluna = pacgo.posicaoInicial.coluna 414 | } 415 | } 416 | } 417 | 418 | dorme(100) 419 | } 420 | } 421 | 422 | func ativarInvencibilidade(milisegundos time.Duration) { 423 | pacgo.invencivel = true 424 | go func() { 425 | dorme(milisegundos) 426 | pacgo.invencivel = false 427 | }() 428 | } 429 | 430 | func buscaFantasma(posicao Posicao) (int, *Fantasma) { 431 | for i, fantasma := range fantasmas { 432 | if fantasma.posicao == posicao { 433 | return i, fantasma 434 | } 435 | } 436 | return -1, nil 437 | } 438 | 439 | func criarFantasmaTemporizado(fantasma *Fantasma, milisegundos time.Duration) { 440 | dorme(milisegundos) 441 | criarFantasma(fantasma.posicao, fantasma.figura) 442 | } 443 | 444 | func matarFantasma(fantasma *Fantasma) { 445 | pos, _ := buscaFantasma(fantasma.posicao) 446 | fantasmas = append(fantasmas[:pos], fantasmas[pos+1:]...) 447 | fmt.Print("\x07") 448 | } 449 | -------------------------------------------------------------------------------- /legacy/utils.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | "os/exec" 7 | "regexp" 8 | ) 9 | 10 | // Tela é a struct que define uma tela 11 | type Tela struct{} 12 | 13 | var tela Tela 14 | 15 | func inicializa() { 16 | rawMode := exec.Command("/bin/stty", "cbreak", "-echo") 17 | rawMode.Stdin = os.Stdin 18 | _ = rawMode.Run() 19 | rawMode.Wait() 20 | 21 | tela = Tela{} 22 | } 23 | 24 | func finaliza() { 25 | rawMode := exec.Command("/bin/stty", "-cbreak", "echo") 26 | rawMode.Stdin = os.Stdin 27 | _ = rawMode.Run() 28 | rawMode.Wait() 29 | } 30 | 31 | func (posicao1 *Posicao) adiciona(posicao2 *Posicao) Posicao { 32 | return Posicao{posicao1.linha + posicao2.linha, posicao1.coluna + posicao2.coluna} 33 | } 34 | 35 | func (pacgo *PacGo) incrementaIndice() { 36 | if pacgo.contadorFig.contador == pacgo.contadorFig.max { 37 | if pacgo.indiceFig == len(pacgo.figuras)-1 { 38 | pacgo.indiceFig = 0 39 | } else { 40 | pacgo.indiceFig++ 41 | } 42 | pacgo.contadorFig.contador = 0 43 | } else { 44 | pacgo.contadorFig.contador++ 45 | } 46 | 47 | } 48 | 49 | // ESC é a string que define o comando escape 50 | const ESC = "\x1b" 51 | 52 | func (tela *Tela) limpa() { 53 | fmt.Printf("%s[2J", ESC) 54 | tela.moveCursor(Posicao{0, 0}) 55 | } 56 | 57 | func (tela *Tela) moveCursor(p Posicao) { 58 | fmt.Printf("%s[%d;%df", ESC, p.linha+1, p.coluna+1) 59 | } 60 | 61 | func vermelho(s string) string { return ansi(31, s) } 62 | func verde(s string) string { return ansi(32, s) } 63 | func azul(s string) string { return ansi(34, s) } 64 | func fundoVermelho(s string) string { return ansi(41, s) } 65 | func fundoVerde(s string) string { return ansi(42, s) } 66 | func fundoAzul(s string) string { return ansi(44, s) } 67 | func intenso(s string) string { return ansi(1, s) } 68 | 69 | var ansiRE *regexp.Regexp 70 | 71 | func ansi(code int, s string) string { 72 | if ansiRE == nil { 73 | ansiRE = regexp.MustCompile(`^` + ESC + `\[(\d+(?:;\d+)*m.*` + ESC + `\[0m)$`) 74 | } 75 | 76 | parts := ansiRE.FindStringSubmatch(s) 77 | if parts == nil { 78 | return fmt.Sprintf("%s[%dm%s%s[0m", ESC, code, s, ESC) 79 | } 80 | return fmt.Sprintf("%s[%d;%s", ESC, code, parts[1]) 81 | } 82 | -------------------------------------------------------------------------------- /main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bufio" 5 | "errors" 6 | "fmt" 7 | "log" 8 | "math/rand" 9 | "os" 10 | "time" 11 | ) 12 | 13 | type Entrada int 14 | 15 | // Possiveis entradas do usuário 16 | const ( 17 | Nada = iota 18 | ParaCima 19 | ParaBaixo 20 | ParaEsquerda 21 | ParaDireita 22 | SairDoJogo // Tecla ESC 23 | ) 24 | 25 | type PacGo struct { 26 | posicao Posicao 27 | posInicial Posicao 28 | figura string 29 | pontos int 30 | vidas int 31 | pilula bool 32 | } 33 | 34 | type Fantasma struct { 35 | posicao Posicao 36 | figura string 37 | } 38 | 39 | type Labirinto struct { 40 | largura int 41 | altura int 42 | mapa []string 43 | numPastilhas int 44 | } 45 | 46 | var pacgo PacGo 47 | var fantasmas []*Fantasma 48 | var labirinto Labirinto 49 | 50 | func criarPacGo(pos Posicao, fig string) { 51 | pacgo = PacGo{ 52 | posicao: pos, 53 | posInicial: pos, 54 | figura: fig, 55 | vidas: 2, 56 | } 57 | } 58 | 59 | func criarFantasma(posicao Posicao, figura string) { 60 | fantasma := &Fantasma{posicao: posicao, figura: figura} 61 | fantasmas = append(fantasmas, fantasma) 62 | } 63 | 64 | func leEntradaDoUsuario(canal chan<- Entrada) { 65 | array := make([]byte, 10) 66 | 67 | for { 68 | lido, _ := os.Stdin.Read(array) 69 | 70 | if lido == 1 && array[0] == 0x1b { 71 | canal <- SairDoJogo 72 | } else if lido == 3 { 73 | if array[0] == 0x1b && array[1] == '[' { 74 | switch array[2] { 75 | case 'A': 76 | canal <- ParaCima 77 | case 'B': 78 | canal <- ParaBaixo 79 | case 'C': 80 | canal <- ParaDireita 81 | case 'D': 82 | canal <- ParaEsquerda 83 | } 84 | } 85 | } 86 | } 87 | } 88 | 89 | func inicializarLabirinto(arquivo string) error { 90 | var ErrMapNotFound = errors.New("Não conseguiu ler o arquivo do mapa") 91 | 92 | // aplica o valor default caso não seja passado um arquivo 93 | var tmpArquivo string 94 | tmpArquivo = arquivo 95 | if tmpArquivo == "" { 96 | tmpArquivo = "./mapas/mapa01.txt" 97 | } 98 | 99 | // abre arquivo 100 | file, err := os.Open(tmpArquivo) 101 | if err != nil { 102 | log.Fatal(err) 103 | return ErrMapNotFound 104 | } 105 | // fecha depois de ler o arquivo 106 | defer file.Close() 107 | 108 | // inicializa o mapa vazio 109 | mapa := []string{} 110 | 111 | // cria um leitor para ler linha a linha o arquivo 112 | scanner := bufio.NewScanner(file) 113 | for scanner.Scan() { 114 | linha := scanner.Text() 115 | mapa = append(mapa, linha) 116 | } 117 | 118 | // determina o tamanho do mapa baseado no arquivo lido 119 | largura := len(mapa[0]) 120 | altura := len(mapa) 121 | 122 | labirinto = Labirinto{ 123 | largura: largura, 124 | altura: altura, 125 | mapa: mapa, 126 | } 127 | 128 | // Processa caracteres especiais 129 | for linha, linhaMapa := range labirinto.mapa { 130 | for coluna, caractere := range linhaMapa { 131 | switch caractere { 132 | case 'G': 133 | criarPacGo(Posicao{linha, coluna}, "\xF0\x9F\x98\x83") 134 | case 'F': 135 | criarFantasma(Posicao{linha, coluna}, "\xF0\x9F\x91\xBB") 136 | case '.': 137 | labirinto.numPastilhas++ 138 | } 139 | } 140 | } 141 | 142 | return nil 143 | } 144 | 145 | func desenhaTela() { 146 | LimpaTela() 147 | 148 | // Imprime placar 149 | MoveCursor(Posicao{0, 0}) 150 | placar := fmt.Sprintf("Pontos: %d Vidas: %d", pacgo.pontos, pacgo.vidas) 151 | fmt.Println(Vermelho(Intenso(placar))) 152 | 153 | // Ajuste para desenhar o mapa embaixo do placar 154 | deslocamento := Posicao{2, 0} 155 | MoveCursor(deslocamento) 156 | 157 | // Imprime mapa 158 | for _, linha := range labirinto.mapa { 159 | for _, char := range linha { 160 | switch char { 161 | case '#': 162 | if pacgo.pilula { 163 | fmt.Print(FundoVermelho(" ")) 164 | } else { 165 | fmt.Print(FundoAzul(" ")) 166 | } 167 | case '.': 168 | fmt.Print(".") 169 | case 'P': 170 | fmt.Print("\xF0\x9F\x8D\x84") 171 | default: 172 | fmt.Print(" ") 173 | } 174 | } 175 | fmt.Println("") 176 | } 177 | 178 | // Imprime PacGo 179 | MoveCursor(pacgo.posicao.Soma(deslocamento)) 180 | fmt.Printf("%s", pacgo.figura) 181 | 182 | // Imprime fantasmas 183 | for _, fantasma := range fantasmas { 184 | MoveCursor(fantasma.posicao.Soma(deslocamento)) 185 | fmt.Printf("%s", fantasma.figura) 186 | } 187 | 188 | // Move cursor para fora do labirinto 189 | MoveCursor(deslocamento.Soma(Posicao{labirinto.altura + 2, 0})) 190 | } 191 | 192 | func moverPacGo(m Entrada) { 193 | var novaLinha = pacgo.posicao.linha 194 | var novaColuna = pacgo.posicao.coluna 195 | 196 | switch m { 197 | case ParaCima: 198 | novaLinha-- 199 | if novaLinha < 0 { 200 | novaLinha = labirinto.altura - 1 201 | } 202 | case ParaBaixo: 203 | novaLinha++ 204 | if novaLinha >= labirinto.altura { 205 | novaLinha = 0 206 | } 207 | case ParaDireita: 208 | novaColuna++ 209 | if novaColuna >= labirinto.largura { 210 | novaColuna = 0 211 | } 212 | case ParaEsquerda: 213 | novaColuna-- 214 | if novaColuna < 0 { 215 | novaColuna = labirinto.largura - 1 216 | } 217 | } 218 | 219 | conteudoDoMapa := labirinto.mapa[novaLinha][novaColuna] 220 | if conteudoDoMapa != '#' { 221 | pacgo.posicao.linha = novaLinha 222 | pacgo.posicao.coluna = novaColuna 223 | 224 | if conteudoDoMapa == '.' || conteudoDoMapa == 'P' { 225 | switch conteudoDoMapa { 226 | case '.': 227 | pacgo.pontos += 10 228 | labirinto.numPastilhas-- 229 | case 'P': 230 | pacgo.pontos += 100 231 | ativarPilula() 232 | } 233 | 234 | // Remove item do mapa 235 | linha := labirinto.mapa[novaLinha] 236 | linha = linha[:novaColuna] + " " + linha[novaColuna+1:] 237 | labirinto.mapa[novaLinha] = linha 238 | } 239 | } 240 | } 241 | 242 | func moverFantasmas() { 243 | for _, fantasma := range fantasmas { 244 | // gera um número aleatório entre 0 e 4 (Direita = 3) 245 | var direcao = rand.Intn(ParaDireita + 1) 246 | 247 | var novaPosicao = fantasma.posicao 248 | 249 | // Atualiza posição testando os limites do mapa 250 | switch direcao { 251 | case ParaCima: 252 | novaPosicao.linha-- 253 | if novaPosicao.linha < 0 { 254 | novaPosicao.linha = labirinto.altura - 1 255 | } 256 | case ParaBaixo: 257 | novaPosicao.linha++ 258 | if novaPosicao.linha > labirinto.altura-1 { 259 | novaPosicao.linha = 0 260 | } 261 | case ParaEsquerda: 262 | novaPosicao.coluna-- 263 | if novaPosicao.coluna < 0 { 264 | novaPosicao.coluna = labirinto.largura - 1 265 | } 266 | case ParaDireita: 267 | novaPosicao.coluna++ 268 | if novaPosicao.coluna > labirinto.largura-1 { 269 | novaPosicao.coluna = 0 270 | } 271 | } 272 | 273 | // Verifica se a posição nova do mapa é válida 274 | conteudoMapa := labirinto.mapa[novaPosicao.linha][novaPosicao.coluna] 275 | if conteudoMapa != '#' { 276 | fantasma.posicao = novaPosicao 277 | } 278 | } 279 | } 280 | 281 | func dorme(milisegundos time.Duration) { 282 | time.Sleep(time.Millisecond * milisegundos) 283 | } 284 | 285 | func detectarColisao() *Fantasma { 286 | for _, fantasma := range fantasmas { 287 | if fantasma.posicao == pacgo.posicao { 288 | return fantasma 289 | } 290 | } 291 | return nil 292 | } 293 | 294 | func main() { 295 | // Inicializar terminal 296 | Inicializa() 297 | defer Finaliza() 298 | 299 | // Lê parâmetros do sistema operacional 300 | args := os.Args[1:] 301 | var arquivo string 302 | if len(args) >= 1 { 303 | arquivo = args[0] 304 | } else { 305 | arquivo = "" 306 | } 307 | 308 | // Inicializar labirinto 309 | inicializarLabirinto(arquivo) 310 | 311 | // Cria rotina para ler entradas 312 | canal := make(chan Entrada, 10) 313 | go leEntradaDoUsuario(canal) 314 | 315 | // Loop principal 316 | for { 317 | // Desenha tela 318 | desenhaTela() 319 | 320 | // Fim de jogo 321 | if labirinto.numPastilhas == 0 { 322 | MoveCursor(Posicao{labirinto.altura + 3, 0}) 323 | fmt.Print("Fim de jogo! Você venceu! \xF0\x9F\x98\x84\n\n") 324 | break 325 | } 326 | 327 | // Processa entrada do jogador 328 | var tecla Entrada 329 | select { 330 | case tecla = <-canal: 331 | default: 332 | } 333 | 334 | if tecla == SairDoJogo { 335 | break 336 | } else { 337 | moverPacGo(tecla) 338 | } 339 | 340 | // Processa movimento dos fantasmas 341 | moverFantasmas() 342 | 343 | // Processa colisões 344 | if fantasma := detectarColisao(); fantasma != nil { 345 | if pacgo.pilula { 346 | go ressucitarFantasma(fantasma, 10000) // 10 segundos 347 | matarFantasma(fantasma) 348 | pacgo.pontos += 500 349 | } else { 350 | pacgo.vidas-- 351 | 352 | // Reseta posição do PacGopher para a posição inicial 353 | pacgo.posicao = pacgo.posInicial 354 | } 355 | 356 | if pacgo.vidas < 0 { 357 | MoveCursor(Posicao{labirinto.altura + 3, 0}) 358 | fmt.Print("Fim de jogo! Os fantasmas venceram... \xF0\x9F\x98\xAD\n\n") 359 | break 360 | } 361 | } 362 | 363 | // Dorme 364 | dorme(100) 365 | } 366 | } 367 | 368 | func ativarPilula() { 369 | pacgo.pilula = true 370 | go desativarPilula(10000) // 10 segundos 371 | } 372 | 373 | func desativarPilula(milisegundos time.Duration) { 374 | dorme(milisegundos) 375 | pacgo.pilula = false 376 | } 377 | 378 | func ressucitarFantasma(fantasma *Fantasma, milisegundos time.Duration) { 379 | dorme(milisegundos) 380 | criarFantasma(fantasma.posicao, fantasma.figura) 381 | } 382 | 383 | func matarFantasma(fantasma *Fantasma) { 384 | var indice int 385 | for idx, f := range fantasmas { 386 | if f.posicao == fantasma.posicao { 387 | indice = idx 388 | break 389 | } 390 | } 391 | fantasmas = append(fantasmas[:indice], fantasmas[indice+1:]...) 392 | } 393 | -------------------------------------------------------------------------------- /mapas/mapa01.txt: -------------------------------------------------------------------------------- 1 | "####################", 2 | "# F#", 3 | "# ##### ##### #", 4 | "# # # #", 5 | "# ##### ##### #", 6 | " ", 7 | "# ##### ##### #", 8 | "# # # #", 9 | "#...##### ##### #", 10 | "#G..P F#", 11 | "####################", -------------------------------------------------------------------------------- /mapas/mapa02.txt: -------------------------------------------------------------------------------- 1 | ####### 2 | ############### 3 | ####################### 4 | ########################### 5 | ####..........P..........#### 6 | ###...........###...........### 7 | ###....F....#########.........### 8 | ####........###########........#### 9 | ####.......#############.......#### 10 | ####........###########........#### 11 | ###....G....#########....F....### 12 | ###...........###...........### 13 | ####.....................#### 14 | ########################### 15 | ####################### 16 | ############### 17 | ####### 18 | 19 | -------------------------------------------------------------------------------- /mapas/mapa03.txt: -------------------------------------------------------------------------------- 1 | ############################ 2 | #............##............# 3 | #.####.#####.##.#####.####.# 4 | #P####.#####.##.#####.####P# 5 | #..........................# 6 | #.####.##.########.##.####.# 7 | #......##....##....##......# 8 | ######.##### ## #####.###### 9 | #.## ##.# 10 | #.## ###--### ##.# 11 | ######.## # FFFF # ##.###### 12 | . # FFFF # . 13 | ######.## # FFFF # ##.###### 14 | #.## ######## ##.# 15 | #.## G ##.# 16 | ######.## ######## ##.###### 17 | #............##............# 18 | #.####.#####.##.#####.####.# 19 | #P..##................##..P# 20 | ###.##.##.########.##.##.### 21 | #......##....##....##......# 22 | #.##########.##.##########.# 23 | #..........................# 24 | ############################ 25 | -------------------------------------------------------------------------------- /utils.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | "os/exec" 7 | "regexp" 8 | ) 9 | 10 | /* Coordenadas na tela */ 11 | type Posicao struct { 12 | linha int 13 | coluna int 14 | } 15 | 16 | /* Aplica um deslocamento na posição. */ 17 | func (pos1 *Posicao) Soma(pos2 Posicao) Posicao { 18 | return Posicao{pos1.linha + pos2.linha, pos1.coluna + pos2.coluna} 19 | } 20 | 21 | /* Inicializa prepara o terminal para funcionar como base do jogo. */ 22 | func Inicializa() { 23 | rawMode := exec.Command("/bin/stty", "cbreak", "-echo") 24 | rawMode.Stdin = os.Stdin 25 | _ = rawMode.Run() 26 | rawMode.Wait() 27 | } 28 | 29 | /* Finaliza restaura o terminal para o estado original. */ 30 | func Finaliza() { 31 | rawMode := exec.Command("/bin/stty", "-cbreak", "echo") 32 | rawMode.Stdin = os.Stdin 33 | _ = rawMode.Run() 34 | rawMode.Wait() 35 | } 36 | 37 | const ESC = "\x1b" 38 | 39 | /* limpaTela Limpa a tela e volta o cursor para a posição inicial. */ 40 | func LimpaTela() { 41 | fmt.Printf("%s[2J", ESC) 42 | MoveCursor(Posicao{0,0}) 43 | } 44 | 45 | /* MoveCursor Move o cursor para as coordendas definidas pela posição p */ 46 | func MoveCursor(p Posicao) { 47 | fmt.Printf("%s[%d;%df", ESC, p.linha + 1, p.coluna + 1) 48 | } 49 | 50 | func Vermelho(s string) string { return ansi(31, s) } 51 | func Verde(s string) string { return ansi(32, s) } 52 | func Azul(s string) string { return ansi(34, s) } 53 | func FundoVermelho(s string) string { return ansi(41, s) } 54 | func FundoVerde(s string) string { return ansi(42, s) } 55 | func FundoAzul(s string) string { return ansi(44, s) } 56 | func Intenso(s string) string { return ansi(1, s) } 57 | 58 | var ansiRE *regexp.Regexp 59 | 60 | func ansi(code int, s string) string { 61 | if ansiRE == nil { 62 | ansiRE = regexp.MustCompile(`^` + ESC + `\[(\d+(?:;\d+)*m.*` + ESC + `\[0m)$`) 63 | } 64 | 65 | parts := ansiRE.FindStringSubmatch(s) 66 | if parts == nil { 67 | return fmt.Sprintf("%s[%dm%s%s[0m", ESC, code, s, ESC) 68 | } else { 69 | return fmt.Sprintf("%s[%d;%s", ESC, code, parts[1]) 70 | } 71 | 72 | return "" 73 | } 74 | --------------------------------------------------------------------------------