Changeset 3d333fd in Readingame


Ignore:
Timestamp:
Aug 19, 2023, 3:57:25 PM (10 months ago)
Author:
PulkoMandy <pulkomandy@…>
Branches:
main
Children:
a607072
Parents:
3d27dc6
Message:

Continue adding things

  • Fix main window layout (text view sizing)
  • Implement conditional messages (partially)
  • Implements some more opcodes around flags
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • HyperTextView.cpp

    r3d27dc6 r3d333fd  
    201201
    202202
     203bool
     204HyperTextView::HasHeightForWidth()
     205{
     206        return BView::HasHeightForWidth();
     207}
     208
     209
     210void
     211HyperTextView::GetHeightForWidth(float width, float* min, float* max, float* preferred)
     212{
     213        BView::GetHeightForWidth(width, min, max, preferred);
     214}
     215
     216
    203217void
    204218HyperTextView::SetText(const char* text)

  • HyperTextView.h

    r3d27dc6 r3d333fd  
    2929        virtual void                            Clicked(HyperTextView* view, BPoint where,
    3030                                                                        BMessage* message);
    31 
    3231private:
    3332        int32 fMessage;
    … …  
    5049        virtual void                            MouseMoved(BPoint where, uint32 transit,
    5150                                                                        const BMessage* dragMessage);
     51
     52        virtual bool                            HasHeightForWidth() override;
     53        virtual void                            GetHeightForWidth(float width, float* min,
     54                                                                        float* max, float* preferred) override;
    5255
    5356                        void                            SetText(const char* text);

  • main.cpp

    r3d27dc6 r3d333fd  
    1717#include <String.h>
    1818#include <TextEncoding.h>
    19 #include <TextView.h>
    2019#include <Window.h>
    2120
    … …  
    2726
    2827#define BOLD "\x1B[34m"
     28#define COLOR "\x1B[33m"
    2929#define NORMAL "\x1B[0m"
    3030
    … …  
    177177std::vector<uint8_t> gVar8;
    178178std::vector<uint16_t> gVar16;
     179std::vector<bool> gVar1;
    179180
    180181uint8_t gCurrentRoom;
    181182uint8_t gCurrentScreen;
     183uint8_t gHomeScreen;
    182184uint8_t gTrigger;
     185uint8_t gGlobalTrigger;
    183186
    184187// TODO objects
    … …  
    202205                        fMainText->MakeEditable(false);
    203206                        fMainText->MakeSelectable(false);
    204                         //fMainText->SetInsets(10, 10, 10, 10);
     207                        fMainText->SetInsets(10, 10, 10, 10);
    205208
    206209                        fInlineButton = new BButton("button", NULL);
    … …  
    208211                        BLayoutBuilder::Group<>(this, B_VERTICAL)
    209212                                .SetInsets(0, 0, 0, B_USE_WINDOW_SPACING)
    210                                 .Add(fMainText, 999)
    211                                 .AddGroup(B_HORIZONTAL)
     213                                .Add(fMainText, 1)
     214                                .AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING, 0)
     215                                        .GetLayout(&fLayout)
    212216                                        .AddGlue()
    213217                                        .Add(fInlineButton)
    214218                                        .AddGlue()
    215219                                .End()
    216                                 .AddGlue(0)
    217220                        .End();
    218221                }
    … …  
    228231                }
    229232
     233                void SetButtonVisible(bool visible)
     234                {
     235                        int32 index = fLayout->IndexOfView(fInlineButton);
     236                        fLayout->ItemAt(index)->SetVisible(visible);
     237                }
     238
    230239                void SetMainText(const std::string& text)
    231240                {
    232241                        Lock();
    233                         fInlineButton->Hide();
     242                        SetButtonVisible(false);
    234243                        fMainText->SetText("");
    235244
    … …  
    267276                                                break;
    268277                                        }
     278                                        case '{':
     279                                        {
     280                                                text_run_array runs;
     281                                                runs.count = 1;
     282                                                runs.runs->font = be_plain_font;
     283                                                runs.runs->offset = 0;
     284                                                runs.runs->color = make_color(0, 0, 0);
     285                                                fMainText->Insert(decoded, &runs);
     286                                                decoded = "";
     287                                                cursor += HandleConditional(message, cursor);
     288                                                break;
     289                                        }
    269290                                        case '@':
    270291                                        case '$':
    271292                                                // @ Gender mark (print an e if the player identifies as female)
    272293                                                // $ Plural mark (print an s if the counter is plural)
    273                                                 printf(BOLD "%c" NORMAL, message[cursor]);
     294                                                printf(COLOR "%c" NORMAL, message[cursor]);
    274295                                                cursor++;
    275296                                                break;
    … …  
    291312                }
    292313
     314                int ParseInt(const std::string& message, int& cursor)
     315                {
     316                        int v = 0;
     317                        while (isdigit(message[cursor])) {
     318                                v = v * 10 + message[cursor] - '0';
     319                                cursor++;
     320                        }
     321
     322                        return v;
     323                }
     324
     325                int HandleConditional(const std::string& message, int cursor)
     326                {
     327                        int icursor = cursor;
     328                        // {%f3|%m2~%m3}
     329                        cursor++;
     330                        if (message[cursor] != '%' || message[cursor + 1] != 'f') {
     331                                fprintf(stderr, "Unknwown message conditional\n");
     332                                return 1;
     333                        }
     334
     335                        cursor += 2;
     336
     337                        int flagToCheck = ParseInt(message, cursor);
     338                        uint8_t valueToCheck = gVar8[flagToCheck];
     339
     340                        if (message[cursor] != '|') {
     341                                fprintf(stderr, "Unknwown message conditional action\n");
     342                                return 1;
     343                        }
     344
     345                        for(;;) {
     346                                if (!valueToCheck && message[cursor] == '|')
     347                                        break;
     348                                if (valueToCheck && message[cursor] == '~')
     349                                        break;
     350                                cursor++;
     351                        }
     352                        cursor++;
     353
     354                        if (message[cursor] != '%' || message[cursor + 1] != 'm') {
     355                                fprintf(stderr, "Unknwown message output %c%c\n", message[cursor], message[cursor + 1]);
     356                        }
     357                        cursor += 2;
     358
     359                        int messageToDisplay = ParseInt(message, cursor);
     360                        BString decodedMessage;
     361                        PrettyPrint(gRooms[gCurrentRoom].fMessages[messageToDisplay - 1], decodedMessage);
     362                        fMainText->Insert(decodedMessage);
     363
     364                        do {
     365                                cursor++;
     366                        } while (message[cursor] != '}');
     367                        cursor++;
     368
     369                        return cursor - icursor;
     370                }
     371
    293372                int HandleHyperlink(const std::string& message, int cursor)
    294373                {
    … …  
    324403                        if (message[cursor] == 'o') {
    325404                                fInlineButton->SetLabel("OK");
    326                                 fInlineButton->Show();
     405                                SetButtonVisible(true);
    327406                                int v = 0;
    328407                                int i = 1;
    … …  
    334413                                return i + 1;
    335414                        } else if (message[cursor] == '!') {
    336                                 printf(BOLD "APPEND" NORMAL "\n");
     415                                printf(COLOR "APPEND" NORMAL "\n");
    337416                                return 2;
    338417                        } else {
    339418                                // TODO unknown escape sequence
    340                                 fprintf(stderr, "ERROR: unknown escape sequence %c", message[cursor]);
     419                                fprintf(stderr, "ERROR: unknown escape sequence %c\n", message[cursor]);
    341420                                return 2;
    342421                        }
    … …  
    346425                HyperTextView* fMainText;
    347426                BButton* fInlineButton;
     427                BGroupLayout* fLayout;
    348428                BPrivate::BTextEncoding fDecoder;
    349429};
    … …  
    375455                bool runNextLine = true;
    376456                int line = 0;
    377                 while (runNextLine) {
     457                while (runNextLine && (line < gRooms[0].fScripts.size())) {
     458                        printf("[%02x:%02x] ", 0, line);
     459                        disassemble(gRooms[0].fScripts[line]);
    378460                        runNextLine = RunScriptLine(gRooms[0].fScripts[line]);
    379461                        line++;
    … …  
    388470                        int line = 0;
    389471                        bool runNextLine = true;
    390                         while (runNextLine) {
     472                        printf("\nTRIGGER: %02x\n", gTrigger);
     473                        gCurrentScreen = gHomeScreen;
     474                        while (runNextLine && (line < gRooms[0].fScripts.size())) {
     475                                printf("[%02x:%02x] ", 0, line);
     476                                disassemble(gRooms[0].fScripts[line]);
    391477                                runNextLine = RunScriptLine(gRooms[0].fScripts[line]);
    392478                                line++;
    393479                        }
     480                        puts("---");
    394481                        line = 0;
    395                         while (runNextLine) {
     482                        while (runNextLine && (line < gRooms[gCurrentRoom].fScripts.size())) {
     483                                printf("[%02x:%02x] ", gCurrentRoom, line);
     484                                disassemble(gRooms[gCurrentRoom].fScripts[line]);
    396485                                runNextLine = RunScriptLine(gRooms[gCurrentRoom].fScripts[line]);
    397486                                line++;
    … …  
    414503                                {
    415504                                        done = true;
     505                                        break;
     506                                }
     507                                case 0x01:
     508                                {
     509                                        uint8_t varAddress = script[pc++];
     510                                        if (gVar8[varAddress] != 0) {
     511                                                continue;
     512                                        } else {
     513                                                done = true;
     514                                                runNextLine = true;
     515                                        }
     516                                        break;
     517                                }
     518                                case 0x03:
     519                                {
     520                                        uint8_t varAddress = script[pc++];
     521                                        if (gVar1[varAddress] == 0) {
     522                                                continue;
     523                                        } else {
     524                                                done = true;
     525                                                runNextLine = true;
     526                                        }
    416527                                        break;
    417528                                }
    … …  
    427538                                                runNextLine = true;
    428539                                        }
     540                                        break;
    429541                                }
    430542                                case 0x0D:
    … …  
    432544                                        uint8_t eventToCheck = script[pc++];
    433545                                        if (gTrigger == eventToCheck) {
    434                                                 fprintf(stderr, "unknown param to 0D: %02x\n", script[pc++]);
    435                                                 disassemble(script);
     546                                                fprintf(stderr, "    unknown param to 0D: %02x\n", script[pc++]);
    436547                                                continue;
    437548                                        } else {
    … …  
    445556                                        uint8_t eventToCheck = script[pc++];
    446557                                        // FIXME is it really gTrigger here, or should it be something else?
    447                                         if (gTrigger == eventToCheck)
     558                                        if (gGlobalTrigger == eventToCheck) {
     559                                                gGlobalTrigger++;
    448560                                                continue;
    449                                         else {
     561                                        } else {
    450562                                                done = true;
    451563                                                runNextLine = true;
    … …  
    453565                                        break;
    454566                                }
     567                                case 0x7E:
    455568                                case 0x7F:
    456569                                {
    457570                                        // FIXME figure this out
    458                                         pc++;
     571                                        break;
     572                                }
     573                                case 0x81:
     574                                {
     575                                        uint8_t varAddress = script[pc++];
     576                                        gVar8[varAddress]++;
     577                                        break;
     578                                }
     579                                case 0x83:
     580                                {
     581                                        uint8_t varAddress = script[pc++];
     582                                        gVar1[varAddress] = true;
    459583                                        break;
    460584                                }
    … …  
    467591                                        break;
    468592                                }
     593                                case 0x8A:
     594                                {
     595                                        uint8_t varAddress = script[pc++];
     596                                        uint16_t varValue = script[pc++];
     597                                        varValue = varValue | (script[pc++] << 8);
     598                                        gVar16[varAddress] -= varValue;
     599                                        break;
     600                                }
    469601                                case 0x8F:
    470602                                {
    … …  
    479611                                case 0x93:
    480612                                {
    481                                         gCurrentScreen = script[pc++];
     613                                        gHomeScreen = script[pc++];
     614                                        gCurrentScreen = gHomeScreen;
    482615                                        break;
    483616                                }
    … …  
    489622                                        break;
    490623                                }
     624                                case 0xA0:
     625                                {
     626                                        // FIXME: the global hooks are always evaluated anyways?
     627                                        pc += 3;
     628                                        break;
     629                                }
     630                                case 0xFC:
     631                                {
     632                                        printf("Game over");
     633                                        done = true;
     634                                        break;
     635                                }
    491636                                default:
    492637                                        fprintf(stderr, "ERROR: unknown opcode %02x at %04x\n", script[pc - 1], pc - 1);
    493                                         disassemble(script);
     638                                        for (int k = 0; k < script.size(); k++) {
     639                                                if (k == pc - 1)
     640                                                        printf("*");
     641                                                printf("%02x ", script[k]);
     642                                        }
     643                                        puts("");
    494644                                        done = true;
    495645                                        break;
    … …  
    683833
    684834        // TODO how many variables are there?
     835        gVar1.resize(16);
    685836        gVar8.resize(16);
    686837        gVar16.resize(16);
    687838
    688         /*
    689839        int i = 0;
    690840        for (const auto& room: gRooms) {
    … …  
    694844                for (auto text: room.fMessages) {
    695845                        printf("------ SCREEN %d -------\n", j + 1);
    696                         prettyPrint(text);
     846                        printf("%s\n", text.c_str());
    697847                        j++;
    698848                }
    699849
     850        /*
    700851                j = 0;
    701852                for (auto script: room.fScripts) {
    … …  
    704855                        j++;
    705856                }
     857        */
    706858                i++;
    707859        }
    708         */
    709860
    710861        Readingame app;
Note: See TracChangeset for help on using the changeset viewer.