Example #1
0
 public static void Remember()
 {
     if (S == null)
     {
         return;
     }
     S.XSSRState = XSSR.GetState();
     Prior       = new ImmutableState(S);
 }
Example #2
0
        public Entry()
        {
            State s = new State();

            s.Entities     = new EntityDictionary();
            s.Initiative   = new Schedule();
            s.TurnsLeft    = 0;
            s.DungeonStart = new Dungeon(TilesetType.DEFAULT_DUNGEON, 40, 40); //ROUND_ROOMS_DIAGONAL_CORRIDORS
            var spawnPoint = s.DungeonStart.LogicWorld.RandomMatch(Dungeon.Floor);


            Seeker       = new Dijkstra(s.DungeonStart.LogicWorld);
            VisualRandom = new XSRandom();
            BeingDamaged = new Dictionary <string, bool>();

//            Player.Seeker.SetGoal(Player.Pos.Y, Player.Pos.X);
//            Player.Seeker.Scan();

            for (int i = 0; i < 6; i++)
            {
                do
                {
                    if (s.Entities.Contains(spawnPoint))
                    {
                        spawnPoint = s.DungeonStart.LogicWorld.RandomMatch(Dungeon.Floor);
                        continue;
                    }
                    Entity player =
                        new Entity("Hero " + ((char)(65 + i)), "@" + WeaponGlyphs[i], _playerColors[i], spawnPoint.Y,
                                   spawnPoint.X, 5, 3 + XSSR.Next(4), 0).UpdateStats(health: new Gauge(10), damage: 3);
                    // \u1202
                    player.Seeker = new Dijkstra(s.DungeonStart.LogicWorld);
                    s.Entities.Add(player);
                    spawnPoint = s.DungeonStart.LogicWorld.RandomMatch(Dungeon.Floor);
                    break;
                } while (true);
            }

            for (int i = 0; i < 25; i++)
            {
                spawnPoint = s.DungeonStart.LogicWorld.RandomMatch(Dungeon.Floor);
                if (spawnPoint.Y >= 0 && !s.Entities.Contains(spawnPoint))
                {
                    Entity baddie = new Entity("Baddie " + (char)(65 + i), "b" + IconGlyphs.RandomElement(), _bloodRed, spawnPoint.Y, spawnPoint.X, 4, XSSR.Next(1, 5), -1);
                    baddie.Seeker = new Dijkstra(s.DungeonStart.LogicWorld);
//                    baddie.Seeker.SetGoal(baddie.Pos.Y, baddie.Pos.X);
//                    baddie.Seeker.Scan();
                    s.Entities.Add(baddie);
                }
            }
            foreach (var k in s.Entities.NameToEntity.Keys)
            {
                IEnumerable <Position> foes =
                    s.Entities.NameToEntity.Where(kv => kv.Value.Faction != s.Entities[k].Faction)
                    .Select(e => e.Value.Pos);
                s.Entities[k] = s.Entities[k].AddEnemies(foes);
                IEnumerable <Position> friends =
                    s.Entities.NameToEntity.Where(kv => kv.Value.Faction == s.Entities[k].Faction)
                    .Select(e => e.Value.Pos);
                s.Entities[k] = s.Entities[k].AddAllies(friends);
            }
            s.StepsTaken = 0;
            s.XSSRState  = XSSR.GetState();
            H.S          = s;

            H.ResetInitiative();
            Entity first = H.S.Entities[H.S.Initiative.PeekTurn().Actor];

            H.S.CurrentActor = first.Name;
            H.S.Cursor       = first.Pos;
            H.S.Camera       = first.Pos;
            if (first.Faction == 0)
            {
                Seeker.SetGoal(first.Pos.Y, first.Pos.X);
                Seeker.Scan(first);

                H.S.CurrentReason = WaitReason.Receiving;
                H.Remember();
            }


            //            Player.Seeker.GetPath(Player.Y, Player.X);
        }
Example #3
0
        public void RunEntry()
        {
            do
            {
                if (Terminal.HasInput())
                {
                    Input = Terminal.Read();
                }
                else
                {
                    continue;
                }
                if (Input == Terminal.TK_S)
                {
                    H.S.XSSRState = XSSR.GetState();
                    using (FileStream fs = new FileStream("Savefile.sav", FileMode.Create, FileAccess.Write))
                    {
                        BinaryFormatter bf = new BinaryFormatter();
                        bf.Serialize(fs, H.S);
                    }
//                    File.WriteAllText("Savefile.json", JsonConvert.SerializeObject(S));
                }
                else if (Input == Terminal.TK_LBRACKET)
                {
                    continue;
                }
                else if (Input == Terminal.TK_RBRACKET)
                {
                    continue;
                }
                switch (H.S.CurrentReason)
                {
                case WaitReason.WalkAnimating:
                {
                }
                break;

                case WaitReason.Receiving:
                {
                    Entity acting = H.S.Entities[H.S.CurrentActor];
                    switch (Input)
                    {
                    case Terminal.TK_MOUSE_LEFT:
                    {
                        Position temp = new Position((Terminal.State(Terminal.TK_MOUSE_Y) - 1) + OffsetY, (Terminal.State(Terminal.TK_MOUSE_X) - 1) / 2 + OffsetX);
                        H.S.Cursor = temp;
                        //if (H.S.Cursor.Validate(H.S.DungeonStart.Height, H.S.DungeonStart.Width))
                        //    acting.Seeker.GetPath(acting, acting.Pos, H.S.Cursor, acting.Stats.MoveSpeed);
                        H.S.Cursor.MakeValid(H.S.DungeonStart.Height, H.S.DungeonStart.Width);
                        if (acting.Seeker.Path.Contains(H.S.Cursor))
                        {
                            Seeker.ClearGoals();
                            H.S.CurrentReason = WaitReason.WalkAnimating;
                        }
                        else if (H.S.Cursor == acting.Pos)
                        {
                            acting.Seeker.Path.Add(acting.Pos);
                            Seeker.ClearGoals();
                            H.S.CurrentReason = WaitReason.WalkAnimating;
                        }
                    }
                    break;

                    case Terminal.TK_MOUSE_MOVE:
                    {
                        Position temp = new Position((Terminal.State(Terminal.TK_MOUSE_Y) - 1) + OffsetY, (Terminal.State(Terminal.TK_MOUSE_X) - 1) / 2 + OffsetX);
                        H.S.Cursor = temp;
                        if (H.S.Cursor.Validate(H.S.DungeonStart.Height, H.S.DungeonStart.Width))
                        {
                            acting.Seeker.GetPath(acting, acting.Pos, H.S.Cursor, acting.Stats.MoveSpeed);
                        }
                        H.S.Cursor.MakeValid(H.S.DungeonStart.Height, H.S.DungeonStart.Width);
                    }
                    break;

                    case Terminal.TK_LEFT:
                    case Terminal.TK_KP_4:
                    case Terminal.TK_H:
                    {
                        if (H.S.DungeonStart.LogicWorld[H.S.Entities[H.S.CurrentActor].Pos.Y, H.S.Entities[H.S.CurrentActor].Pos.X - 1] == Dungeon.Floor)
                        {
                            H.S.Entities.Move(H.S.CurrentActor, 0, -1);
                            FinishMove();
                        }
                    }
                    break;

                    case Terminal.TK_RIGHT:
                    case Terminal.TK_KP_6:
                    case Terminal.TK_L:
                    {
                        if (H.S.DungeonStart.LogicWorld[H.S.Entities[H.S.CurrentActor].Pos.Y, H.S.Entities[H.S.CurrentActor].Pos.X + 1] == Dungeon.Floor)
                        {
                            H.S.Entities.Move(H.S.CurrentActor, 0, 1);
                            FinishMove();
                        }
                    }
                    break;

                    case Terminal.TK_UP:
                    case Terminal.TK_KP_8:
                    case Terminal.TK_K:
                    {
                        if (H.S.DungeonStart.LogicWorld[H.S.Entities[H.S.CurrentActor].Pos.Y - 1, H.S.Entities[H.S.CurrentActor].Pos.X] == Dungeon.Floor)
                        {
                            H.S.Entities.Move(H.S.CurrentActor, -1, 0);
                            FinishMove();
                        }
                    }
                    break;

                    case Terminal.TK_DOWN:
                    case Terminal.TK_KP_2:
                    case Terminal.TK_J:
                    {
                        if (H.S.DungeonStart.LogicWorld[H.S.Entities[H.S.CurrentActor].Pos.Y + 1, H.S.Entities[H.S.CurrentActor].Pos.X] == Dungeon.Floor)
                        {
                            H.S.Entities.Move(H.S.CurrentActor, 1, 0);
                            FinishMove();
                        }
                    }
                    break;
                    }
                }
                break;
                }
            } while (Input != Terminal.TK_CLOSE && Input != Terminal.TK_Q);


            Terminal.Close(); // terminal_close();
        }