DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download

⟦63229f20a⟧ Ada Source

    Length: 16384 (0x4000)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Vaisseau, seg_05c1b1

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

E3 Source Code



with Bd_Jeu;
with Services;  
with Tir;
with Gen;
use Gen;
with Solide;
with Maitre;  
with Calendar;
use Calendar;
with Base;
with Tir;
with Asteroide;
package body Vaisseau is

    Nb : Integer := 0;
    type T_Vaisseau;
    type A_Vaisseau is access T_Vaisseau;
    type Internal is
        record
            Mon_Solide : Solide.Objet;
            T : A_Vaisseau;
        end record;
    package Bd_Vaisseau is new Bd_Jeu (Solide => Objet, No_Solide => null);
    task type T_Vaisseau is
        entry Creer (Mon_Solide : in Solide.Objet; No : in Numero);
        entry Collision (Tiers : in Gen.Tgenre; Fin : out Boolean);
        entry Top (Ordre : in Character;
                   Fin : out Boolean;
                   Tiers : out Gen.Tgenre;
                   Position : out Gen.Tposition);
        entry Detruire;
    end T_Vaisseau;

    task body T_Vaisseau is
        Moi : Solide.Objet;  
        Loc_Tiers : Gen.Tgenre := Gen.Non_Objet;
        Loc_Fin, En_Vie : Boolean := True;
        Loc_Sens : Gen.Tsens := Gen.Sud;
        Loc_Position : Gen.Tposition;
        Limite : Boolean;
        Mon_No : Numero;  
        Prochain_Tir : Calendar.Time;
        Mon_Tir : Tir.Objet;
        Position_Tir : Gen.Tposition;
        Hors_Ecran : Boolean;

        procedure Traiter_Collision
                     (Tiers : in Gen.Tgenre; Fin : out Boolean) is
        begin
            case Tiers is
                when Gen.Vaisseau | Gen.Asteroide =>
                    Fin := True;
                when Gen.Tir =>
                    Solide.Vider (Le_Solide => Moi,
                                  Energie => Maitre.Energie_Choc);
                    if Solide.Vide (Le_Solide => Moi) then
                        Fin := True;
                    else
                        Fin := False;
                    end if;
                when Gen.Base =>
                    Solide.Doper (Le_Solide => Moi,
                                  Energie => Maitre.Energie_Ravitaillement);
                    Fin := False;
                when Gen.Non_Objet =>
                    Fin := False;
            end case;
        end Traiter_Collision;

    begin
        accept Creer (Mon_Solide : in Solide.Objet; No : in Numero) do
            Moi := Mon_Solide;
            Mon_No := No;
            Prochain_Tir := Calendar.Clock;
        end Creer;
        while En_Vie loop
            Solide.Afficher (Le_Solide => Moi);
            select
                accept Collision (Tiers : in Gen.Tgenre; Fin : out Boolean) do
                    Traiter_Collision (Tiers => Tiers, Fin => Loc_Fin);
                    Fin := Loc_Fin;
                end Collision;
            or
                accept Top (Ordre : in Character;
                            Fin : out Boolean;
                            Tiers : out Gen.Tgenre;
                            Position : out Gen.Tposition) do
                    Loc_Fin := False;
                    Position := Gen.Position_Nulle;
                    Loc_Tiers := Gen.Non_Objet;
                    if Services.Traduire (Ordre => Ordre) = Gen.Deplacement then
                        Loc_Sens := Services.Sens (Ordre => Ordre);
                        Solide.Deplacer (Le_Solide => Moi,
                                         Sens => Loc_Sens,
                                         Tiers => Loc_Tiers,
                                         Position => Position);
                        Traiter_Collision (Tiers => Loc_Tiers, Fin => Loc_Fin);
                    elsif Services.Traduire (Ordre => Ordre) = Gen.Feu then
                        if Calendar.Clock > Prochain_Tir then
                            Position_Tir := Solide.Position (Le_Solide => Moi);
                            Services.Calculer (Position => Position_Tir,
                                               Sens => Loc_Sens,
                                               Hors_Ecran => Hors_Ecran);
                            Position_Tir.Sens := Loc_Sens;  
                            Mon_Tir := Tir.Creer (Position => Position_Tir);
                            Prochain_Tir := Calendar.Clock + Maitre.Delai_Tir;
                        end if;
                    else
                        null;
                    end if;
                    Fin := Loc_Fin;
                    Tiers := Loc_Tiers;
                end Top;
            or
                accept Detruire do
                    Solide.Detruire (Le_Solide => Moi);
                    En_Vie := False;
                    if Loc_Fin then
                        Maitre.Ecrire (X => Maitre.Last_X / 4,
                                       Y => Maitre.Last_Y / 2,
                                       S => "TERMINE POUR VOUS",
                                       T => Integer (Mon_No),
                                       Blink => True);
                    else
                        Maitre.Ecrire (X => Maitre.Last_X / 4,
                                       Y => Maitre.Last_Y / 2,
                                       S => "  BRAVO  ",
                                       T => Integer (Mon_No),
                                       Blink => True);
                    end if;
                end Detruire;
            end select;
        end loop;
    end T_Vaisseau;

    function Creer (Position : in Gen.Tposition;
                    Energie : in Gen.Tenergie;
                    No : in Numero) return Objet is
        Loc_Vaisseau : Objet := new Internal;
    begin  
        Loc_Vaisseau.Mon_Solide :=
           Solide.Creer (Un_Solide => Loc_Vaisseau,
                         Position => Position,
                         Energie => Energie,
                         Figure => Services.To_Char (Integer (No)));
        Loc_Vaisseau.T := new T_Vaisseau;
        Bd_Vaisseau.Inserer (Le_Solide => Loc_Vaisseau, No => Integer (No));
        Loc_Vaisseau.T.Creer (Mon_Solide => Loc_Vaisseau.Mon_Solide, No => No);
        return Loc_Vaisseau;
    end Creer;

    procedure Top (Le_Vaisseau : in Objet;
                   Ordre : in Character;
                   Fin : out Boolean;
                   Tiers : out Gen.Tgenre;
                   Position : out Gen.Tposition) is
    begin
        Le_Vaisseau.T.Top
           (Ordre => Ordre, Fin => Fin, Tiers => Tiers, Position => Position);
    end Top;

    procedure Collision (Le_Vaisseau : in Objet;
                         Tiers : in Gen.Tgenre;
                         Fin : out Boolean) is
    begin
        Le_Vaisseau.T.Collision (Tiers => Tiers, Fin => Fin);
    end Collision;

    procedure Detruire (Le_Vaisseau : in out Objet) is
    begin
        Bd_Vaisseau.Retirer (Le_Solide => Le_Vaisseau);
        Le_Vaisseau.T.Detruire;
        Le_Vaisseau := null;
    end Detruire;

    procedure Initialiser is
        Un_Vaisseau : Objet;  
        Position : Gen.Tposition;
    begin  
        Position.Y := 1;
        for Nb in 1 .. Maitre.Dernier_Term loop
            Position.X := Nb * 8;
            Un_Vaisseau := Creer (Position => Position,
                                  Energie => Maitre.Energie_Vaisseau,
                                  No => Numero (Nb));
        end loop;
    end Initialiser;

    procedure Commander_Vaisseau (C : in Character; No : in Integer) is
        Un_Vaisseau : Objet;
        Asteroide_Percutee : Asteroide.Objet;
        Base_Percutee : Base.Objet;
        Tir_Percute : Tir.Objet;
        Vaisseau_Percute : Vaisseau.Objet;
        Tiers : Gen.Tgenre;
        Fin : Boolean;
        Position : Gen.Tposition;
    begin
        Un_Vaisseau := Bd_Vaisseau.Prendre (No);
        Top (Le_Vaisseau => Un_Vaisseau,
             Ordre => C,
             Tiers => Tiers,
             Fin => Fin,
             Position => Position);
        if Fin then
            Detruire (Le_Vaisseau => Un_Vaisseau);
            Fin := False;
        end if;
        case Tiers is
            when Gen.Asteroide =>
                Asteroide_Percutee := Solide.Prendre (Position => Position);
                Asteroide.Collision (L_Asteroide => Asteroide_Percutee,
                                     Tiers => Gen.Vaisseau,
                                     Fin => Fin);
                if Fin then
                    Asteroide.Detruire (L_Asteroide => Asteroide_Percutee);
                end if;
            when Gen.Tir =>
                Tir_Percute := Solide.Prendre (Position => Position);
                Tir.Collision
                   (Le_Tir => Tir_Percute, Tiers => Gen.Vaisseau, Fin => Fin);
                if Fin then
                    Tir.Detruire (Le_Tir => Tir_Percute);
                end if;
            when Gen.Vaisseau =>
                Vaisseau_Percute := Solide.Prendre (Position => Position);
                Vaisseau.Collision (Le_Vaisseau => Vaisseau_Percute,
                                    Tiers => Gen.Vaisseau,
                                    Fin => Fin);
                if Fin then
                    Vaisseau.Detruire (Le_Vaisseau => Vaisseau_Percute);
                end if;
            when Gen.Base =>
                Base_Percutee := Solide.Prendre (Position => Position);
                Base.Collision (La_Base => Base_Percutee,
                                Tiers => Gen.Vaisseau,
                                Fin => Fin);
                if Fin then
                    Base.Detruire (La_Base => Base_Percutee);
                end if;
            when Gen.Non_Objet =>
                null;
        end case;
    end Commander_Vaisseau;

    procedure Traiter (Nb_Vaisseau : out Integer) is
        Nb : Integer := 0;
        Un_Vaisseau : Objet;
    begin
        Bd_Vaisseau.Init;
        Un_Vaisseau := Bd_Vaisseau.Prendre;
        while Un_Vaisseau /= null loop
            Nb := Nb + 1;
            Bd_Vaisseau.Suivant;
            Un_Vaisseau := Bd_Vaisseau.Prendre;
        end loop;  
        Nb_Vaisseau := Nb;
    end Traiter;

    procedure Terminer is  
        Un_Vaisseau : Objet;
    begin
        Bd_Vaisseau.Init;
        Un_Vaisseau := Bd_Vaisseau.Prendre;
        while Un_Vaisseau /= null loop
            Detruire (Le_Vaisseau => Un_Vaisseau);
            Un_Vaisseau := Bd_Vaisseau.Prendre;
        end loop;
    end Terminer;
end Vaisseau;

E3 Meta Data

    nblk1=f
    nid=f
    hdr6=18
        [0x00] rec0=25 rec1=00 rec2=01 rec3=032
        [0x01] rec0=1a rec1=00 rec2=0b rec3=03c
        [0x02] rec0=18 rec1=00 rec2=04 rec3=04e
        [0x03] rec0=10 rec1=00 rec2=03 rec3=014
        [0x04] rec0=14 rec1=00 rec2=0a rec3=05a
        [0x05] rec0=17 rec1=00 rec2=06 rec3=088
        [0x06] rec0=04 rec1=00 rec2=0d rec3=024
        [0x07] rec0=20 rec1=00 rec2=08 rec3=018
        [0x08] rec0=1b rec1=00 rec2=02 rec3=01e
        [0x09] rec0=14 rec1=00 rec2=05 rec3=052
        [0x0a] rec0=1b rec1=00 rec2=09 rec3=010
        [0x0b] rec0=10 rec1=00 rec2=0e rec3=000
        [0x0c] rec0=19 rec1=00 rec2=08 rec3=044
        [0x0d] rec0=05 rec1=00 rec2=09 rec3=000
        [0x0e] rec0=00 rec1=00 rec2=00 rec3=019
    tail 0x2176b6902895942191bad 0x42a00088462060003
Free Block Chain:
  0xf: 0000  00 07 00 39 80 21 63 5f 56 61 69 73 73 65 61 75  ┆   9 !c_Vaisseau┆
  0x7: 0000  00 0c 00 65 80 03 20 3d 3e 03 00 50 20 20 20 20  ┆   e   =>  P    ┆
  0xc: 0000  00 00 03 fc 80 17 67 65 6e 72 65 20 3a 3d 20 47  ┆      genre := G┆