initial commit (Tutorial Tuesdays 2024)

.gitignore

@@ -0,0 +1,23 @@
+# Python byte-compiled files
+__pycache__/
+
+# Python virtual environment
+venv/
+
+# mypy
+.mypy_cache/
+
+# Ruff
+.ruff_cache/
+
+# build artifacts
+build/
+dist/
+
+# IDEs and editors
+.vscode/
+.idea/
+*.swp
+
+# user data
+yarc.sav

LICENSE.txt

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

README.md

@@ -0,0 +1,44 @@
+# Yet Another Rogue Clone
+
+![2024 logo](https://i.imgur.com/GEyBFMC.png)
+
+This is my entry for the 2024
+"[RoguelikeDev Does The Complete Roguelike Tutorial](https://www.reddit.com/r/roguelikedev/comments/1dt8bqm/roguelikedev_does_the_complete_roguelike_tutorial/)"
+event.
+
+The goal is to recreate the classic Rogue game with modern technology,
+following the steps outlined in the tutorial series.
+
+This project is developed using Python 3.12 and the
+[python-tcod](https://github.com/libtcod/python-tcod) library.
+
+## License
+
+This project is licensed under the CC0 1.0 Universal (CC0 1.0) Public Domain
+Dedication.
+
+You can copy, modify, distribute, and perform the work, even for commercial
+purposes, all without asking permission.
+
+For more details, you can view the full text of the license at
+[https://creativecommons.org/publicdomain/zero/1.0/](https://creativecommons.org/publicdomain/zero/1.0/).
+
+## Acknowledgments
+
+Some code was adapted from the following projects:
+
+- [Another Roguelike Tutorial 2021](https://libtcod.github.io/tutorials/python/2021/) by Kyle Benesch (CC0 license)
+
+- [Yet Another Roguelike Tutorial](https://rogueliketutorials.com/tutorials/tcod/v2/) by Tyler Standridge and Kyle Benesch (CC0 license)
+
+Thank you to the authors and contributors of these projects for their
+invaluable work!
+
+This project would not have been possible without the support of
+the [python-tcod](https://github.com/libtcod/python-tcod) library. Special
+thanks to the developers and community behind python-tcod for their
+contributions and dedication.
+
+A heartfelt shout-out to the original authors of the Rogue game. Neither this
+project nor the larger roguelike scene would be possible without their
+pioneering work and creativity.

game/action.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from game.combat import melee_attack
+from game.constants import Glyph
+from game.entity import Actor, ArmorItem, Item, Player, WeaponItem
+from game.level import Level
+from game.messages import MessageLog
+
+
+class Action:
+    # return True if this action ends the actor's turn
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        raise NotImplementedError()
+
+
+class MoveAction(Action):
+    def __init__(self, dx: int, dy: int):
+        self.dx, self.dy = dx, dy
+
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        assert level.in_bounds(actor.x + self.dx, actor.y + self.dy)
+        new_x, new_y = actor.x + self.dx, actor.y + self.dy
+        if not level.is_walkable(new_x, new_y):
+            return False
+        if not level.is_connected(actor.x, actor.y, new_x, new_y):
+            return False
+        actor.x, actor.y = new_x, new_y
+        if isinstance(actor, Player):
+            self._auto_pickup(actor, level, log)
+        return True
+
+    @staticmethod
+    def _auto_pickup(actor: Player, level: Level, log: MessageLog) -> None:
+        item_on_floor = level.get_item_at(actor.x, actor.y)
+        if not item_on_floor:
+            return
+        if item_on_floor.gold:
+            level.entities.remove(item_on_floor)
+            actor.gold += item_on_floor.gold
+            log.append(f"You pick up {item_on_floor.gold} gold.")
+        else:
+            if actor.inventory.add_item(item_on_floor):
+                level.entities.remove(item_on_floor)
+                log.append(f"You pick up a {item_on_floor.name}.")
+            else:
+                log.append("Your inventory is full.")
+
+
+class MeleeAction(Action):
+    def __init__(self, target: Actor):
+        self.target = target
+
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        assert level.in_bounds(self.target.x, self.target.y)
+        assert level.is_walkable(self.target.x, self.target.y)
+        if not level.is_connected(actor.x, actor.y, self.target.x, self.target.y):
+            return False
+        melee_attack(actor, self.target, level, log)
+        if self.target.ai:
+            self.target.ai.attacked(self.target, level)
+        return True
+
+
+class BumpAction(Action):
+    def __init__(self, dx: int, dy: int):
+        self.dx, self.dy = dx, dy
+
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        action: Action
+        dest_x, dest_y = actor.x + self.dx, actor.y + self.dy
+        if not level.in_bounds(dest_x, dest_y):
+            return False
+        target = level.get_actor_at(dest_x, dest_y)
+        if target:
+            action = MeleeAction(target)
+        else:
+            action = MoveAction(self.dx, self.dy)
+        return action.perform(actor, level, log)
+
+
+class WaitAction(Action):
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        return True
+
+
+class StairsAction(Action):
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        assert isinstance(actor, Player)
+        if (actor.x, actor.y) == (level.stairs_x, level.stairs_y):
+            level.completed = True
+            log.append("You descend the staircase.")
+        else:
+            log.append("There are no stairs here.")
+        return False
+
+
+class DropAction(Action):
+    def __init__(self, item: Item):
+        self.item = item
+
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        assert isinstance(actor, Player)
+        if level.get_item_at(actor.x, actor.y):
+            log.append("There is already something on the floor.")
+            return False
+        actor.inventory.remove_item(self.item)
+        self.item.x, self.item.y = actor.x, actor.y
+        level.entities.add(self.item)
+        log.append(f"You drop a {self.item.name}.")
+        return True
+
+
+class ConsumeAction(Action):
+    def __init__(self, item: Item):
+        self.item = item
+
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        assert isinstance(actor, Player)
+        assert self.item.consumable
+        actor.inventory.remove_item(self.item)
+        self.item.consumable.use(actor, level, log)
+        return True
+
+
+class WieldAction(Action):
+    def __init__(self, item: Item):
+        assert isinstance(item, WeaponItem)
+        self.item = item
+
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        assert isinstance(actor, Player)
+        actor.inventory.weapon_slot = self.item
+        log.append(f"You wield a {self.item.name}.")
+        return True
+
+
+class WearAction(Action):
+    def __init__(self, item: Item):
+        assert isinstance(item, ArmorItem)
+        self.item = item
+
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        assert isinstance(actor, Player)
+        actor.inventory.armor_slot = self.item
+        log.append(f"You wear a {self.item.name}.")
+        return True
+
+
+class UseAction(Action):
+    def __init__(self, item: Item):
+        self.item = item
+
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        action: Action
+        if self.item.glyph == Glyph.WEAPON:
+            action = WieldAction(self.item)
+        elif self.item.glyph == Glyph.ARMOR:
+            action = WearAction(self.item)
+        elif self.item.glyph == Glyph.SCROLL:
+            log.append("As you read it, the scroll crumbles into dust.")
+            action = ConsumeAction(self.item)
+        else:
+            assert self.item.glyph == Glyph.POTION
+            action = ConsumeAction(self.item)
+        return action.perform(actor, level, log)
+
+
+class TakeOffAction(Action):
+    def perform(self, actor: Actor, level: Level, log: MessageLog) -> bool:
+        assert isinstance(actor, Player)
+        if actor.inventory.armor_slot:
+            actor.inventory.armor_slot = None
+            log.append("You take your armor off.")
+            return True
+        else:
+            log.append("You have nothing to take off.")
+            return False