Exemplo n.º 1
0
        public static void BindCharacterToGame(
            AsyncRPGDataContext context,
            int character_id,
            int new_game_id)
        {
            // Get the most recent event that occurred in the new game
            int last_game_event_id = GameEventQueries.GetLastGameEvent(context, new_game_id);

            // Tell the character which game they are bound to
            // and set an initial location
            var dbCharacter =
                (from c in context.Characters
                 where c.CharacterID == character_id
                 select c).Single();

            dbCharacter.GameID = new_game_id;
            dbCharacter.RoomX = 0;
            dbCharacter.RoomY = 0;
            dbCharacter.RoomZ = 0;
            dbCharacter.X = 0;
            dbCharacter.Y = 0;
            dbCharacter.Z = 0;
            dbCharacter.Angle = 0;
            dbCharacter.LastSentEventID = last_game_event_id;
            dbCharacter.NewEventsPosted = false;

            context.SubmitChanges();
        }
Exemplo n.º 2
0
 public static void DeleteCharacter(
     AsyncRPGDataContext context,
     int character_id)
 {
     context.Characters.DeleteOnSubmit(context.Characters.Single(c => c.CharacterID == character_id));
     context.SubmitChanges();
 }
Exemplo n.º 3
0
        // Database Config Interface
        //--------------------------
        public static void InitializeConfig(
            AsyncRPGDataContext context,
            int version,
            string appUrl,
            string appDebugUrl,
            string clientUrl,
            string emailAddress,
            string emailHost,
            int emailPort,
            string emailUsername,
            string emailPassword,
            string ircServer,
            int ircPort)
        {
            Config config = new Config
            {
                Version = version,
                AppURL = appUrl,
                AppDebugURL = appDebugUrl,
                ClientURL = clientUrl,
                EmailAddress = emailAddress,
                EmailHost = emailHost,
                EmailPort = emailPort,
                EmailUserName = emailUsername,
                EmailPassword = emailPassword,
                IrcServer = ircServer,
                IrcPort = ircPort
            };

            context.Configs.InsertOnSubmit(config);
            context.SubmitChanges();
        }
Exemplo n.º 4
0
        public static void CreateCharacter(
            AsyncRPGDataContext context,
            int account_id,
            string name,
            GameConstants.eGender gender,
            GameConstants.eArchetype archetype,
            int picture_id)
        {
            Characters newCharacter = new Characters
            {
                AccountID= account_id,
                GameID= -1,
                RoomX = 0,
                RoomY = 0,
                RoomZ = 0,
                LastPingTime = DateTime.Now,
                LastSentEventID = -1,
                NewEventsPosted = false,
                X= 0.0f,
                Y= 0.0f,
                Z= 0.0f,
                Angle= 0.0f,
                Name= name,
                Gender = (gender == GameConstants.eGender.Male),
                Archetype = (int)archetype,
                PictureID = picture_id,
                PowerLevel= 1,
                Energy= 0
            };

            context.Characters.InsertOnSubmit(newCharacter);
            context.SubmitChanges();
        }
Exemplo n.º 5
0
 public RequestCache(
     ICacheAdapter sessionCache,
     AsyncRPGDataContext dbContext)
 {
     m_sessionCache = sessionCache;
     m_dbContext = dbContext;
     m_requestRoomCache = null;
 }
Exemplo n.º 6
0
 public static string GetRoomStaticData(
     AsyncRPGDataContext context,
     RoomKey roomKey)
 {
     return
         (from r in context.Rooms
          where r.GameID == roomKey.game_id && r.X == roomKey.x && r.Y == roomKey.y && r.Z == roomKey.z
          select r.StaticData).Single();
 }
Exemplo n.º 7
0
 public static int GetRoomRandomSeed(
     AsyncRPGDataContext context,
     RoomKey roomKey)
 {
     return
         (from r in context.Rooms
          where r.GameID == roomKey.game_id && r.X == roomKey.x && r.Y == roomKey.y && r.Z == roomKey.z
          select r.RandomSeed).Single();
 }
Exemplo n.º 8
0
 public static bool DoesRoomExist(
     AsyncRPGDataContext context,
     RoomKey roomKey)
 {
     return
         (from r in context.Rooms
          where r.GameID == roomKey.game_id && r.X == roomKey.x && r.Y == roomKey.y && r.Z == roomKey.z
          select r).Count() > 0;
 }
Exemplo n.º 9
0
 public static EnergyTank GetEnergyTank(
     AsyncRPGDataContext db_context,
     int energyTankID)
 {
     return
         EnergyTank.CreateEnergyTank(
             (from e in db_context.EnergyTanks
              where e.EnergyTankID == energyTankID
              select e).Single());
 }
Exemplo n.º 10
0
        public static Portal GetPortal(
            AsyncRPGDataContext context,
            int portal_id)
        {
            var dbPortal=
                (from p in context.Portals
                where p.PortalID == portal_id
                select p).Single();

            return Portal.CreatePortal(dbPortal);
        }
Exemplo n.º 11
0
        public static void UpdateEnergyTankEnergy(
            AsyncRPGDataContext db_context,
            int energyTankID,
            int newEnergy)
        {
            var energyTankQuery =
                (from e in db_context.EnergyTanks
                where e.EnergyTankID == energyTankID
                select e).SingleOrDefault();

            db_context.SubmitChanges();
        }
Exemplo n.º 12
0
        public static void ClearCharacterNewEventFlag(
            AsyncRPGDataContext context,
            int character_id)
        {
            var query = (from c in context.Characters
                         where c.CharacterID == character_id
                         select c).Single();

            query.NewEventsPosted = false;

            context.SubmitChanges();
        }
Exemplo n.º 13
0
        public static WorldTemplate GetWorldGenerationParameters(
            AsyncRPGDataContext context,
            int game_id)
        {
            WorldTemplate worldTemplate = new WorldTemplate();
            Games[] game = (from g in context.Games where g.GameID == game_id select g).ToArray<Games>();

            worldTemplate.dungeon_size = (GameConstants.eDungeonSize)(game[0].DungeonSize);
            worldTemplate.dungeon_difficulty = (GameConstants.eDungeonDifficulty)(game[0].DungeonDifficulty);

            return worldTemplate;
        }
Exemplo n.º 14
0
        public static void UpdateEnergyTankOwnership(
            AsyncRPGDataContext db_context,
            int energyTankID,
            GameConstants.eFaction newOwnership)
        {
            var energyTankQuery =
                (from e in db_context.EnergyTanks
                 where e.EnergyTankID == energyTankID
                 select e).SingleOrDefault();

            energyTankQuery.Ownership = (int)newOwnership;

            db_context.SubmitChanges();
        }
Exemplo n.º 15
0
        public static int CreateGame(
            AsyncRPGDataContext context,
            int account_id,
            string game_name,
            GameConstants.eDungeonSize dungeonSize,
            GameConstants.eDungeonDifficulty dungeonDifficulty,
            bool irc_enabled,
            string irc_server,
            int irc_port,
            bool irc_encryption_enabled)
        {
            int new_game_id = -1;

            // Create a random 256-bit (32 byte) encryption key for encrypting chat
            string irc_encryption_key = RNGUtilities.CreateNonDeterministicRandomBase64String(256);
            Debug.Assert(irc_encryption_key.Length == 44);

            if (irc_server.Length == 0)
            {
                irc_server = IrcConstants.DEFAULT_IRC_SERVER;
            }

            if (irc_port < IrcConstants.LOWEST_VALID_IRC_PORT || irc_port > IrcConstants.HIGHEST_VALID_IRC_PORT)
            {
                irc_port = IrcConstants.DEFAULT_IRC_PORT;
            }

            {
                Games newGame = new Games
                {
                    OwnerAccountID = account_id,
                    Name = game_name,
                    DungeonSize = (int)dungeonSize,
                    DungeonDifficulty = (int)dungeonDifficulty,
                    IrcEnabed = irc_enabled,
                    IrcServer = irc_server,
                    IrcPort = irc_port,
                    IrcEncryptionKey = irc_encryption_key,
                    IrcEncryptionEnabed = irc_encryption_enabled
                };

                context.Games.InsertOnSubmit(newGame);
                context.SubmitChanges();

                new_game_id = newGame.GameID;
            }

            return new_game_id;
        }
Exemplo n.º 16
0
        public static WorldBuilder GetWorldBuilder(
            AsyncRPGDataContext db_context,
            ICacheAdapter cache)
        {
            WorldBuilder worldBuilder = (WorldBuilder)cache["world_builder"];

            if (worldBuilder == null)
            {
                worldBuilder = new WorldBuilder();
                worldBuilder.Initialize(db_context);

                cache["world_builder"] = worldBuilder;
            }

            return worldBuilder;
        }
Exemplo n.º 17
0
        public bool BuildWorld(
            AsyncRPGDataContext db_context,
            int game_id, 
            out World world, 
            out string result)
        {
            bool success = true;
            WorldTemplate worldTemplate = null;
            DungeonLayout layout = null;

            world = null;
            result = SuccessMessages.GENERAL_SUCCESS;

            // Get the world generation parameters from the DB
            worldTemplate =
                WorldQueries.GetWorldGenerationParameters(
                    db_context,
                    game_id);

            // Create the initial set of rooms for the world
            if (success)
            {
                layout = new DungeonLayout(game_id, worldTemplate, m_roomTemplateSet, m_mobSpawnTableSet);

                if (!layout.BuildRoomLayout(out result))
                {
                    success = false;
                }
            }

            // Copy the rooms and portals from the layout into the world
            if (success)
            {
                world = new World(this, layout.LayoutWorldTemplate, game_id);
                world.ApplyLayout(layout);
            }

            // TODO: WorldBuilder: Generate the environment objects, etc

            // Save the cached world into the database
            if (success)
            {
                WorldQueries.InsertWorld(db_context, world);
            }

            return success;
        }
Exemplo n.º 18
0
        public static World GetWorld(
            AsyncRPGDataContext db_context, 
            ICacheAdapter cache, 
            int game_id)
        {
            string world_identifier = GetWorldCacheIdentifier(game_id);
            World world = (World)cache[world_identifier];

            if (world == null)
            {
                world = WorldBuilderCache.GetWorldBuilder(db_context, cache).LazyLoadWorld(db_context, game_id);

                cache[world_identifier] = world;
            }

            return world;
        }
Exemplo n.º 19
0
        public static int GetDatabaseVersion(
            string connection_string)
        {
            int version = -1;

            try
            {
                AsyncRPGDataContext context = new AsyncRPGDataContext(connection_string);

                version = context.Configs.Take(1).Select(c => c.Version).SingleOrDefault();
            }
            catch (System.Exception)
            {
                version = -1;
            }

            return version;
        }
Exemplo n.º 20
0
        public static List<Portal> GetRoomPortals(
            AsyncRPGDataContext context,
            RoomKey roomKey)
        {
            List<Portal> portals = new List<Portal>();

            var query =
                from p in context.Portals
                where p.GameID == roomKey.game_id && p.RoomX == roomKey.x && p.RoomY == roomKey.y && p.RoomZ == roomKey.z
                select p;

            foreach (var dbPortal in query)
            {
                Portal portal = Portal.CreatePortal(dbPortal);

                portals.Add(portal);
            }

            return portals;
        }
Exemplo n.º 21
0
        public static bool BuildWorld(
            AsyncRPGDataContext db_context, 
            ICacheAdapter cache, 
            int game_id, 
            out string result)
        {
            World world = null;

            bool success =
                WorldBuilderCache.GetWorldBuilder(db_context, cache).BuildWorld(db_context, game_id, out world, out result);

            if (success)
            {
                string world_identifier = GetWorldCacheIdentifier(game_id);

                cache[world_identifier] = world;
            }

            return success;
        }
Exemplo n.º 22
0
        public static List<EnergyTank> GetEnergyTanks(
            AsyncRPGDataContext db_context,
            RoomKey roomKey)
        {
            List<EnergyTank> energyTanks = new List<EnergyTank>();

            var roomEnergyTankQuery =
                from e in db_context.EnergyTanks
                where e.GameID == roomKey.game_id && e.RoomX == roomKey.x && e.RoomY == roomKey.y && e.RoomZ == roomKey.z
                select e;

            foreach (EnergyTanks dbEnergyTank in roomEnergyTankQuery)
            {
                EnergyTank energyTank = EnergyTank.CreateEnergyTank(dbEnergyTank);

                energyTanks.Add(energyTank);
            }

            return energyTanks;
        }
Exemplo n.º 23
0
        public static void UpdateEnergyTank(
            AsyncRPGDataContext db_context,
            EnergyTank energyTank)
        {
            var dbEnergyTank =
                (from e in db_context.EnergyTanks
                 where e.EnergyTankID == energyTank.ID
                 select e).SingleOrDefault();

            dbEnergyTank.GameID = energyTank.RoomKey.game_id;
            dbEnergyTank.RoomX = energyTank.RoomKey.x;
            dbEnergyTank.RoomY = energyTank.RoomKey.y;
            dbEnergyTank.RoomZ = energyTank.RoomKey.z;
            dbEnergyTank.X = energyTank.Position.x;
            dbEnergyTank.Y = energyTank.Position.y;
            dbEnergyTank.Z = energyTank.Position.z;
            dbEnergyTank.Ownership = (int)energyTank.Faction;
            dbEnergyTank.Energy = energyTank.Energy;

            db_context.SubmitChanges();
        }
Exemplo n.º 24
0
        //TODO: LoadRoom - Convert this over to a request processor
        public static bool LoadRoom(
            AsyncRPGDataContext context,
            World world,
            RoomKey room_key, 
            out Room room, 
            out string result)
        {
            bool success;
            string json_static_data = WorldQueries.GetRoomStaticData(context, room_key);

            room = null;
            success = false;

            // Load static room data for this room
            if (json_static_data.Length > 0)
            {
                StaticRoomData static_room_data = null;

                try
                {
                    if (json_static_data.Length == 0)
                    {
                        throw new ArgumentException();
                    }

                    static_room_data = JsonMapper.ToObject<StaticRoomData>(json_static_data);
                }
                catch (System.Exception)
                {
                    static_room_data = null;
                }

                if (static_room_data != null)
                {
                    room = new Room(room_key);
                    room.static_room_data = static_room_data;

                    success = true;
                    result = SuccessMessages.GENERAL_SUCCESS;
                }
                else
                {
                    result = ErrorMessages.DB_ERROR + "(Failed to parse room static data)";
                }
            }
            else
            {
                result = ErrorMessages.DB_ERROR + "(Failed to get room static data)";
            }

            // If the static room data parsed, load everything else
            if (success)
            {
                RoomTemplate roomTemplate = world.RoomTemplates.GetTemplateByName(room.static_room_data.room_template_name);

                // Load the random seed for the room
                room.random_seed = WorldQueries.GetRoomRandomSeed(context, room_key);

                // Setup the runtime nav mesh
                room.runtime_nav_mesh = new NavMesh(room.room_key, roomTemplate.NavMeshTemplate);

                // Load all of the portals for this room
                room.portals = WorldQueries.GetRoomPortals(context, room_key);

                // Flag all of the room sides that have portals
                foreach (Portal p in room.portals)
                {
                    room.portalRoomSideBitmask.Set(p.room_side, true);
                }

                // Load mob spawners for this room
                room.mobSpawners = MobQueries.GetMobSpawners(context, world.MobSpawnTables, room_key);
            }

            return success;
        }
Exemplo n.º 25
0
 public void Initialize(AsyncRPGDataContext db_context)
 {
     m_roomTemplates = WorldQueries.LoadRoomTemplates(db_context);
 }
Exemplo n.º 26
0
        public static void DeleteGame(
            AsyncRPGDataContext context,
            int gameid)
        {
            // Detach all of the Characters from the game
            {
                var query =
                    from character in context.Characters
                    where character.GameID == gameid
                    select character;

                foreach (Characters character in query)
                {
                    character.GameID = -1;
                    character.RoomX = 0;
                    character.RoomY = 0;
                    character.RoomZ = 0;
                    character.X = 0;
                    character.Y = 0;
                    character.Z = 0;
                    character.Angle = 0;
                }

                context.SubmitChanges();
            }

            // Free all of the portals
            {
                var query =
                    from portal in context.Portals
                    where portal.GameID == gameid
                    select portal;

                foreach (Portals portal in query)
                {
                    context.Portals.DeleteOnSubmit(portal);
                }

                context.SubmitChanges();
            }

            // Free all of the mobs
            {
                var query =
                    from mob in context.Mobs
                    where mob.GameID == gameid
                    select mob;

                foreach (Mobs mob in query)
                {
                    context.Mobs.DeleteOnSubmit(mob);
                }

                context.SubmitChanges();
            }

            // Free all of the mob spawners
            {
                var query =
                    from mobSpawner in context.MobSpawners
                    where mobSpawner.GameID == gameid
                    select mobSpawner;

                foreach (MobSpawners mobSpawner in query)
                {
                    context.MobSpawners.DeleteOnSubmit(mobSpawner);
                }

                context.SubmitChanges();
            }

            // TODO DeleteGame: Delete loot

            // Free all of the rooms
            {
                var query =
                    from room in context.Rooms
                    where room.GameID == gameid
                    select room;

                foreach (Rooms room in query)
                {
                    context.Rooms.DeleteOnSubmit(room);
                }

                context.SubmitChanges();
            }

            // Free all of the game_events associated from the game
            GameEventQueries.DeleteAllEventsForGame(context, gameid);

            // Finally, Free the game itself
            {
                var query =
                    from game in context.Games
                    where game.GameID == gameid
                    select game;

                foreach (Games game in query)
                {
                    context.Games.DeleteOnSubmit(game);
                }

                context.SubmitChanges();
            }
        }
Exemplo n.º 27
0
 public static bool VerifyGameExists(
     AsyncRPGDataContext context,
     int gameid)
 {
     return (from g in context.Games where g.GameID == gameid select g).Count() > 0;
 }
Exemplo n.º 28
0
 public static bool VerifyAccountOwnsGame(
     AsyncRPGDataContext context,
     int account_id,
     int gameid)
 {
     return
         (from game in context.Games
          where game.GameID == gameid && game.OwnerAccountID == account_id
          select game).Count() > 0;
 }
Exemplo n.º 29
0
        public static void UnBindCharacterFromGame(
            AsyncRPGDataContext context,
            int character_id)
        {
            var dbCharacter =
                (from c in context.Characters
                 where c.CharacterID == character_id
                 select c).Single();

            dbCharacter.GameID = -1;
            dbCharacter.RoomX = 0;
            dbCharacter.RoomY = 0;
            dbCharacter.RoomZ = 0;
            dbCharacter.X = 0;
            dbCharacter.Y = 0;
            dbCharacter.Z = 0;
            dbCharacter.Angle = 0;

            context.SubmitChanges();
        }
Exemplo n.º 30
0
 public static string GetGameName(
     AsyncRPGDataContext context,
     int gameid)
 {
     return (from g in context.Games where g.GameID == gameid select g.Name).Single();
 }