• 0 Posts
  • 89 Comments
Joined 3 years ago
cake
Cake day: July 1st, 2023

help-circle





  • Turns out, there is more than 1.5 billion people in Africa.

    But these are facts I can learn independently of its, you know, appearance on a map. And outside of this being a notable news story, I don’t really see it prompting any such questions.

    so it’s not a question of making people feel better about the size of their country

    It is, though. That’s actually the only purpose this serves.

    I think you might read that as dismissive, but I see some value in making people feel better. Certainly in making the US feel worse.

    I don’t, however, think that this will meaningfully improve anything.

    Russia doesn’t really have this problem anyway, it’s very large in all our popular projections.

    It’s area should still be incorrect, though, yes? Which would mean we have incorrect ideas about its natural resources, its farmland, its cultural cohesion?


  • A country’s, or a continent’s, signifigance has nothing to do with it’s size, though.

    I mean, if we wanted to make the nations of Africa or Greenland feel better, does it follow that we could make them appear bigger on the map than they actually are? Just move the mercator around such that Africa is along the top or bottom edge of the map where things are larger?

    I am absolutely not saying that people having a better understanding of Africa is bad. I just don’t think that this is really how that happens.

    I remember thinking that Russia seemed pretty big on the map, and yet still, I’ve never had to take Russian culture as a class in high school.

    [edit] I’ll add one thing, though. This decision has clearly pissed the US government off, which is based and incredibly funny. I’ll support it to that end.









  • I’m asking you to keep your cock in your pants.

    It is so fucked that in modern life I have to waste my time with conservatives trying to endlessly relitigate exactly what about being a pedophile is bad, and with tech fetishists exactly why being an asshole in public is wrong.

    Spaceballs, if you’re standing somewhere over the grand canyon with your phone out, obviously filming a family of three that does not want to be filmed, what the fuck are you doing? Do you find joy in being an unlikeable loser? Do you often think you just aren’t lonely enough?

    I don’t know what it is you want me to say to you. In my ideal world, Facebook wouldn’t be allowed to make this product in the first place.



  • There is a trick I learned from Firebelley Games (a youtube channel) that is just as simple to spin up and use as the Enum + match strategy but without sacrificing any versatility.

    I actually like it better than the Node-based pattern because you don’t have to set up much boilerplate, and you really don’t need to think about how different state classes might share data. Plus, none of it will clog up your scene tree or need to be pointlessly instantiated by the engine.

    Tap for code

    If you’re on mobile, I would recommend reading this in horizontal view.

    This is all it takes to spin one up:

    class_name Player2D extends Node2D
    
    var _state_machine := CallableStateMachine.new();
    
    func _ready() -> void:
      _state_machine.add_state(
        _state_idle_update,
        Callable(),
        Callable()
      );
      _state_machine.add_state(
        _state_jump_update,
        _state_jump_enter,
        Callable()
      );
      # Set first state
      _state_machine.switch_to(_state_idle_update);
    
    func _process(_delta: float) -> void:
      _state_machine.update();
    
    # These are your state functions.
    func _state_idle_update() -> void;
    func _state_jump_update() -> void;
    func _state_jump_enter() -> void;
    

    The only thing your state machine actually needs to know is which functions are paired together. You can use Callable() to fill in any steps you’re not actually using.

    func _ready() -> void:
      _state_machine.add_state(
        _state_idle_update, # update
        _state_idle_enter,  # enter
        Callable(),         # exit
      );
    

    You call update() yourself, so its timing is completely under your control.

    func _process(delta: float) -> void:
      velocity.y += 9.8 * delta;
      _state_machine.update();
      move_and_slide();
    

    States are keyed by their own update step, so there’s no extra overhead for string names or Enums or the like, and you still get your IDE’s tab autocomplete to help you with 'em.

    func _state_idle_update() -> void:
      if Input.is_action_pressed('jump'):
        _state_machine.switch_to(_state_jump_update);
    

    All state functions exist within the Player2D script, so you have complete access to any shared data or component that Player2D does.

    var _anim: AnimatedSprite2D = $An...;
    var _jump_times := 0;
    
    func _state_idle_enter() -> void:
      _anim.play('idle');
      _jump_times = 0;
    
    func _state_jump_enter() -> void:
      _anim.play('jump');
      _jump_times += 1;
    

    A basic implementation of CallableStateMachine is none too complicated, and you can reuse it anywhere.

    class_name CallableStateMachine extends RefCounted
    
    var _states_map := {} as Dictionary[Callable, CallableState];
    var _current_state: CallableState = null;
    
    func add_state(update: Callable, enter: Callable, exit: Callable) -> void:
      _states_map.set(update, CallableState.new(update, enter, exit));
    
    func switch_to(update: Callable) -> void:
      if not _states_map.has(update):
        return;
      exit();
      _current_state = _states_map.get(update);
      enter();
    
    func update() -> void:
      if _current_state:
        _current_state.update.call();
    
    func enter() -> void:
      if _current_state:
        _current_state.enter.call();
    
    func exit() -> void:
      if _current_state:
        _current_state.exit.call();
    
    # This is just a struct to package the set of functions.
    class CallableState extends RefCounted:
      var update: Callable;
      var enter: Callable;
      var exit: Callable;
      func _init(update: Callable, enter: Callable, exit: Callable) -> void:
        self.update = update;
        self.enter = enter;
        self.exit = exit;
    

    You can do a lot from this base setup, too. I have mine setup such that if I name my functions like this:

    func _state_idle() -> void;
    func _state_idle__update(delta: float) -> void;
    func _state_idle__unhandled_input(event: InputEvent) -> void;
    func _state_idle__exit() -> void;
    

    My state machine automatically knows which step each function is for by the keyword after the double-unders (e.g. ‘__update’), as well as that the nameless _state_idle() is the enter step and the key that I use to switch_to().