diff --git a/Import/bridge.dll b/Import/bridge.dll
new file mode 100644
index 00000000..97d2887c
Binary files /dev/null and b/Import/bridge.dll differ
diff --git a/ReallifeGamemode.Client/ReallifeGamemode.Client.csproj b/ReallifeGamemode.Client/ReallifeGamemode.Client.csproj
index d98e9154..c5577593 100644
--- a/ReallifeGamemode.Client/ReallifeGamemode.Client.csproj
+++ b/ReallifeGamemode.Client/ReallifeGamemode.Client.csproj
@@ -29,6 +29,7 @@
     <Folder Include="assets\html\Reportlist\" />
     <Folder Include="assets\img\atm\" />
     <Folder Include="assets\img\items\" />
+    <Folder Include="Gangwar\" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/ReallifeGamemode.Client/index.ts b/ReallifeGamemode.Client/index.ts
index a88cf8da..7e1d26f4 100644
--- a/ReallifeGamemode.Client/index.ts
+++ b/ReallifeGamemode.Client/index.ts
@@ -180,3 +180,6 @@ planeSchoolHandle(globalData);
 
 import PilotRouteList from './Jobs/PilotRouteSelect';
 PilotRouteList(globalData);
+
+import gangwarHandle from './util/Gangwar';
+gangwarHandle(globalData);
\ No newline at end of file
diff --git a/ReallifeGamemode.Client/util/Gangwar.ts b/ReallifeGamemode.Client/util/Gangwar.ts
new file mode 100644
index 00000000..a917301c
--- /dev/null
+++ b/ReallifeGamemode.Client/util/Gangwar.ts
@@ -0,0 +1,324 @@
+export default function gangwarHandle(globalData: GlobalData) {
+
+    function inside(point, vs) {
+        let x = point[0],
+            y = point[1];
+        let inside = false;
+        for (let i = 0, j = vs.length - 1; i < vs.length; j = i++) {
+            let xi = vs[i][0],
+                yi = vs[i][1];
+            let xj = vs[j][0],
+                yj = vs[j][1];
+            let intersect = ((yi > y) != (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
+            if (intersect) inside = !inside;
+        }
+        return inside;
+    };
+
+    const Natives = {
+        SET_BLIP_CATEGORY: "0x234CDD44D996FD9A",
+        SHOW_HEADING_INDICATOR_ON_BLIP: "0x5FBCA48327B914DF",
+        SET_BLIP_AS_SHORT_RANGE: "0xBE8BE4FE60E27B72",
+        SET_BLIP_DISPLAY: "0x9029B2F3DA924928",
+        SET_BLIP_SPRITE: "0xDF735600A4696DAF",
+        SET_BLIP_ALPHA: "0x45FF974EEE1C8734",
+        ADD_BLIP_FOR_RADIUS: "0x46818D79B1F7499A",
+        SET_BLIP_COLOUR: "0x03D7FB09E75D6B7E",
+        SET_BLIP_ROTATION: "0xF87683CDF73C3F6E",
+        SET_BLIP_FLASHES: "0xB14552383D39CE3E",
+        GET_FIRST_BLIP_INFO_ID: "0x1BEDE233E6CD2A1F",
+        GET_NEXT_BLIP_INFO_ID: "0x14F96AA50D6FBEA7",
+        DOES_BLIP_EXIST: "0xA6DB27D19ECBB7DA"
+    };
+
+    var Gangturf = class {
+
+        name: string;
+        id: number;
+        range: number;
+        x: number;
+        y: number;
+        color: number;
+        colorZone_r: number;
+        colorZone_g: number;
+        colorZone_b: number;
+        rotation: number;
+        owner: string;
+        blip: BlipMp;
+        _colshape: ColshapeMp;
+        vector: Vector3Mp;
+        _status: string;
+        _entered: boolean;
+        _isEntering: boolean;
+        _inColshape: boolean;
+        _timerCheck;
+        edit: boolean;
+
+        constructor(name, id, x, y, range, color, rot, owner, edit) {
+            this._setup(name, id, x, y, range, color, rot, owner, edit);
+        }
+
+        _setup(name, id, x, y, range, color, rot, owner, edit) {
+            var self = this;
+            self.name = name;
+            self.id = id;
+            self.range = range;
+            if (owner = "Ballas") {
+                self.colorZone_r = 143;
+                self.colorZone_g = 0;
+                self.colorZone_b = 199;
+            } else if (owner = "GroveStreet") {
+                self.colorZone_r = 22;
+                self.colorZone_g = 87;
+                self.colorZone_b = 0;
+            } else if (owner = "Neutral") {
+                self.colorZone_r = 255;
+                self.colorZone_g = 255;
+                self.colorZone_b = 255;
+            }
+            self.color = color;
+            self.x = x;
+            self.y = y;
+
+            self.rotation = rot;
+            self._colshape = null;
+            self._status = "normal";
+            self._entered = false;
+            self._isEntering = false;
+            self._inColshape = false;
+            self._timerCheck;
+            self.owner = owner;
+            self.edit = edit;
+            self.loadArea();
+        }
+
+
+
+
+        loadArea() {
+            var self = this;
+            self.blip = mp.game.ui.addBlipForRadius(self.x, self.y, 1, self.range);
+            mp.game.invoke(Natives.SET_BLIP_SPRITE, self.blip, 5);
+            mp.game.invoke(Natives.SET_BLIP_ALPHA, self.blip, 70);
+            mp.game.invoke(Natives.SET_BLIP_COLOUR, self.blip, self.color);
+            self._colshape = mp.colshapes.newCircle(self.x, self.y, self.range * 1.5);
+        }
+        render() {
+
+            var self = this;
+            if (self.blip) {
+                mp.game.invoke(Natives.SET_BLIP_ROTATION, self.blip, self.rotation);
+            }
+            if (self._status == "attack") {
+                if (self.blip) {
+                    if (mp.game.gameplay.getDistanceBetweenCoords(mp.players.local.position.x, mp.players.local.position.y, 0, self.x, self.y, 0, true) < self.range * 1.5) {
+                        var range = Math.sqrt(((self.range * 1.2) * (self.range * 1.2)) + (((self.range * 1.2) / 2) * ((self.range * 1.2) / 2)));
+                        let degrees = (self.rotation + 45) * (Math.PI / 180);
+                        let top_right = {
+                            x: self.x + range * Math.cos(degrees),
+                            y: self.y + range * Math.sin(degrees)
+                        }
+                        degrees = (self.rotation + 135) * (Math.PI / 180);
+                        let top_left = {
+                            x: self.x + range * Math.cos(degrees),
+                            y: self.y + range * Math.sin(degrees)
+                        }
+                        degrees = (self.rotation + 225) * (Math.PI / 180);
+                        let bottom_left = {
+                            x: self.x + range * Math.cos(degrees),
+                            y: self.y + range * Math.sin(degrees)
+                        }
+                        degrees = (self.rotation + 315) * (Math.PI / 180);
+                        let bottom_right = {
+                            x: self.x + range * Math.cos(degrees),
+                            y: self.y + range * Math.sin(degrees)
+                        }
+                        let z = mp.game.gameplay.getGroundZFor3dCoord(mp.players.local.position.x, mp.players.local.position.y, mp.players.local.position.z, 0, false);
+                        //mp.game.graphics.drawLine(bottom_right.x, bottom_right.y, z, bottom_right.x, bottom_right.y, z + 25, 0, 255, 0, 255);
+                        //mp.game.graphics.drawLine(top_left.x, top_left.y, z, top_left.x, top_left.y, z + 25, 0, 0, 255, 255);
+                        let a = 0;
+                        for (var i = z; i < z + 1; i += 0.001) {
+                            mp.game.graphics.drawLine(top_left.x, top_left.y, i, top_right.x, top_right.y, i, self.colorZone_r, self.colorZone_g, self.colorZone_b, 60 - a * 100);
+                            mp.game.graphics.drawLine(top_right.x, top_right.y, i, bottom_right.x, bottom_right.y, i, self.colorZone_r, self.colorZone_g, self.colorZone_b, 60 - a * 100);
+                            mp.game.graphics.drawLine(bottom_right.x, bottom_right.y, i, bottom_left.x, bottom_left.y, i, self.colorZone_r, self.colorZone_g, self.colorZone_b, 60 - a * 100);
+                            mp.game.graphics.drawLine(bottom_left.x, bottom_left.y, i, top_left.x, top_left.y, i, self.colorZone_r, self.colorZone_g, self.colorZone_b, 60 - a * 100);
+                            a += 0.001
+                        }
+                    }
+                    if (self.isInsideArea()) {
+                        mp.game.graphics.drawText(self.name, [self.x, self.y, mp.players.local.position.z + 20], {
+                            font: 7,
+                            color: [255, 255, 255, 185],
+                            scale: [0.4, 0.4],
+                            outline: true,
+                            centre: true
+                        });
+                    }
+                }
+            }
+        }
+
+        updateArea(status, ...args) {
+            var self = this;
+            if (status == "attack") {
+                self._status = "attack";
+                mp.game.invoke(Natives.SET_BLIP_FLASHES, self.blip, true);
+                return;
+            }
+            if (status == "normal") {
+                self._status = "normal";
+                mp.game.invoke(Natives.SET_BLIP_FLASHES, self.blip, false);
+                return;
+            }
+            if (status == "conquered") {
+                self._status = "normal";
+                self.owner = args[1];
+                mp.game.invoke(Natives.SET_BLIP_FLASHES, self.blip, false);
+                self.blip.setColour(args[0]);
+                return;
+            }
+        }
+
+        isTurfArea(shape) {
+            return (shape == this._colshape)
+        }
+
+        isOwner(gang) {
+            return (gang == this.owner)
+        }
+
+        check() {
+           var self = this
+            if (self._entered == true) {
+                if (!self.isInsideArea() || (self.isNearGround() == false)) {
+                    self._entered = false;
+                   // mp.events.callRemote("Gangarea:Leave", self.id);
+                }
+            }
+        }
+    
+        enter() {
+            var self = this;
+            self._timerCheck = setInterval(function () {
+                if ((!self._entered)) {
+                    if (self.isInsideArea() && (self.isNearGround() == true)) {
+                        self._entered = true;
+                        // mp.events.callRemote("Gangarea:Enter", self.id);
+                    }
+                } else if (self._entered == true) {
+                    if (!self.isInsideArea() || (self.isNearGround() == false)) {
+                        self._entered = false;
+                        //mp.events.callRemote("Gangarea:Leave", self.id);
+                    }
+                }
+            }, 1000);
+        }
+
+        leave() {
+            var self = this;
+            clearInterval(self._timerCheck);
+            self.check();
+        }
+        isNearGround() {
+            let self = this;
+            let ground = mp.game.gameplay.getGroundZFor3dCoord(self.x, self.y, 9000, 0, false);
+            let max_diff = 75;
+            let dist = mp.game.system.vdist(0, 0, ground, 0, 0, mp.players.local.position.z);
+            if (dist <= max_diff) {
+                return true;
+            }
+            return false;
+        }
+        isInsideArea() {
+            var self = this;
+            let player = {
+                x: mp.players.local.position.x,
+                y: mp.players.local.position.y,
+                z: mp.players.local.position.z
+            };
+            var range = Math.sqrt(((self.range * 1.2) * (self.range * 1.2)) + (((self.range * 1.2) / 2) * ((self.range * 1.2) / 2)));
+            let degrees = (self.rotation + 45) * (Math.PI / 180);
+            let top_right = {
+                x: self.x + range * Math.cos(degrees),
+                y: self.y + range * Math.sin(degrees)
+            }
+            degrees = (self.rotation + 135) * (Math.PI / 180);
+            let top_left = {
+                x: self.x + range * Math.cos(degrees),
+                y: self.y + range * Math.sin(degrees)
+            }
+            degrees = (self.rotation + 225) * (Math.PI / 180);
+            let bottom_left = {
+                x: self.x + range * Math.cos(degrees),
+                y: self.y + range * Math.sin(degrees)
+            }
+            degrees = (self.rotation + 315) * (Math.PI / 180);
+            let bottom_right = {
+                x: self.x + range * Math.cos(degrees),
+                y: self.y + range * Math.sin(degrees)
+            }
+            let turf = [
+                [top_right.x, top_right.y],
+                [top_left.x, top_left.y],
+                [bottom_left.x, bottom_left.y],
+                [bottom_right.x, bottom_right.y]
+            ]
+            if (inside([player.x, player.y], turf)) {
+                return true;
+            }
+            return false;
+        }
+
+    }
+
+    var gangturfs = [];
+
+    mp.events.add('playerEnterColshape', (shape) => {
+        let turfEntered;
+        gangturfs.forEach(function (turf) {
+            if (turf.isTurfArea(shape) == true) {
+                turfEntered = turf;
+                turfEntered.enter()
+            }
+        });
+    });
+    mp.events.add('playerExitColshape', (shape) => {
+        let turfExitted;
+        gangturfs.forEach(function (turf) {
+            if (turf.isTurfArea(shape) == true) {
+                turfExitted = turf;
+                turfExitted.leave()
+            }
+        });
+    });
+    mp.events.add('render', () => {
+        gangturfs.forEach(function (turf, id) {
+            turf.render();
+        });
+    });
+
+    function clearBlips() {
+        mp.game.gameplay.setThisScriptCanRemoveBlipsCreatedByAnyScript(true);
+        var x = 0;
+        let last_blip = mp.game.invoke(Natives.GET_FIRST_BLIP_INFO_ID, 5);
+
+        while (mp.game.invoke(Natives.DOES_BLIP_EXIST, last_blip)) {
+            mp.game.ui.removeBlip(last_blip);
+            last_blip = mp.game.invoke(Natives.GET_NEXT_BLIP_INFO_ID, 5);
+        }
+    }
+    
+    mp.events.add('GangAreas:Create', (turfsJSON) => {
+        var turfs = JSON.parse(turfsJSON);
+        clearBlips();
+        if (turfs.length > 0) {
+            gangturfs = [];
+            turfs.forEach(function (turf) {
+                if (turf.Id != undefined) {
+                    gangturfs[gangturfs.length] = new Gangturf(turf.Name, turf.Id, turf.X, turf.Y, turf.Range, turf.Color, turf.Rotation, turf.Owner);
+                }
+            });
+        }
+    });
+
+}
\ No newline at end of file
diff --git a/ReallifeGamemode.Database/Entities/Turfs.cs b/ReallifeGamemode.Database/Entities/Turfs.cs
new file mode 100644
index 00000000..d7829c56
--- /dev/null
+++ b/ReallifeGamemode.Database/Entities/Turfs.cs
@@ -0,0 +1,31 @@
+using GTANetworkAPI;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Text;
+
+namespace ReallifeGamemode.Database.Entities
+{
+  public class Turfs
+  {
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    public int Id { get; set; }
+
+    [ForeignKey("Faction")]
+    public int? FactionId { get; set; }
+    public static Faction Faction { get; set; }
+
+    public string Owner { get; set; }
+
+    public string Name { get; set; }
+    public int X { get; set; }
+    public int Y { get; set; }
+    public int Rotation { get; set; }
+    public int Range { get; set; }
+    public int Color { get; set; }
+
+  }
+}
diff --git a/ReallifeGamemode.Database/Migrations/20191129201024_Turfs.Designer.cs b/ReallifeGamemode.Database/Migrations/20191129201024_Turfs.Designer.cs
new file mode 100644
index 00000000..5ba95936
--- /dev/null
+++ b/ReallifeGamemode.Database/Migrations/20191129201024_Turfs.Designer.cs
@@ -0,0 +1,1384 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using ReallifeGamemode.Database.Models;
+
+namespace ReallifeGamemode.Database.Migrations
+{
+    [DbContext(typeof(DatabaseContext))]
+    [Migration("20191129201024_Turfs")]
+    partial class Turfs
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.1.11-servicing-32099")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.ATM", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("Balance");
+
+                    b.Property<bool>("Faulty");
+
+                    b.Property<float>("X");
+
+                    b.Property<float>("Y");
+
+                    b.Property<float>("Z");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ATMs");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Ban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Applied");
+
+                    b.Property<string>("BannedBy");
+
+                    b.Property<string>("Reason");
+
+                    b.Property<int>("UntilDateTime");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Bans");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.BusinessBankAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Balance");
+
+                    b.Property<int>("BusinessId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BusinessId")
+                        .IsUnique();
+
+                    b.ToTable("BusinessBankAccounts");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.BusinessData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("BusinessId");
+
+                    b.Property<int>("Price");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("BusinessData");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.BusRoute", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Description");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("BusRoutes");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.BusRoutePoint", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("BusRouteId");
+
+                    b.Property<string>("Description");
+
+                    b.Property<float>("X");
+
+                    b.Property<float>("Y");
+
+                    b.Property<float>("Z");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BusRouteId");
+
+                    b.ToTable("BusRoutesPoints");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Character", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte>("Ageing");
+
+                    b.Property<float>("AgeingOpacity");
+
+                    b.Property<byte>("BeardColor");
+
+                    b.Property<byte>("Blemishes");
+
+                    b.Property<float>("BlemishesOpacity");
+
+                    b.Property<byte>("Blush");
+
+                    b.Property<byte>("BlushColor");
+
+                    b.Property<float>("BlushOpacity");
+
+                    b.Property<float>("BrowDepth");
+
+                    b.Property<float>("BrowHeight");
+
+                    b.Property<float>("CheekDepth");
+
+                    b.Property<float>("CheekboneHeight");
+
+                    b.Property<float>("CheekboneWidth");
+
+                    b.Property<byte>("ChestHair");
+
+                    b.Property<byte>("ChestHairColor");
+
+                    b.Property<float>("ChestHairOpacity");
+
+                    b.Property<float>("ChinDepth");
+
+                    b.Property<float>("ChinHeight");
+
+                    b.Property<float>("ChinIndent");
+
+                    b.Property<float>("ChinWidth");
+
+                    b.Property<byte>("Complexion");
+
+                    b.Property<float>("ComplexionOpacity");
+
+                    b.Property<byte>("EyeColor");
+
+                    b.Property<float>("EyeSize");
+
+                    b.Property<byte>("EyebrowColor");
+
+                    b.Property<byte>("Eyebrows");
+
+                    b.Property<float>("EyebrowsOpacity");
+
+                    b.Property<byte>("FacialHair");
+
+                    b.Property<float>("FacialHairOpacity");
+
+                    b.Property<byte>("Father");
+
+                    b.Property<byte>("Freckles");
+
+                    b.Property<float>("FrecklesOpacity");
+
+                    b.Property<bool>("Gender");
+
+                    b.Property<byte>("Hair");
+
+                    b.Property<byte>("HairColor");
+
+                    b.Property<byte>("HairHighlightColor");
+
+                    b.Property<float>("JawShape");
+
+                    b.Property<float>("JawWidth");
+
+                    b.Property<float>("LipThickness");
+
+                    b.Property<byte>("Lipstick");
+
+                    b.Property<byte>("LipstickColor");
+
+                    b.Property<float>("LipstickOpacity");
+
+                    b.Property<byte>("Makeup");
+
+                    b.Property<float>("MakeupOpacity");
+
+                    b.Property<byte>("Mother");
+
+                    b.Property<float>("NeckWidth");
+
+                    b.Property<float>("NoseBottomHeight");
+
+                    b.Property<float>("NoseBridgeDepth");
+
+                    b.Property<float>("NoseBroken");
+
+                    b.Property<float>("NoseTipHeight");
+
+                    b.Property<float>("NoseTipLength");
+
+                    b.Property<float>("NoseWidth");
+
+                    b.Property<float>("Similarity");
+
+                    b.Property<float>("SkinSimilarity");
+
+                    b.Property<byte>("SunDamage");
+
+                    b.Property<float>("SunDamageOpacity");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Characters");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.CharacterCloth", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ClothId");
+
+                    b.Property<bool>("Duty");
+
+                    b.Property<int>("SlotId");
+
+                    b.Property<byte>("SlotType");
+
+                    b.Property<int>("Texture");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("CharacterClothes");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.ClothCombination", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Gender");
+
+                    b.Property<int>("Top");
+
+                    b.Property<int>("Torso");
+
+                    b.Property<int>("Undershirt");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ClothCombinations");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Door", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Category");
+
+                    b.Property<int?>("FactionId");
+
+                    b.Property<bool>("Locked");
+
+                    b.Property<int>("Model");
+
+                    b.Property<string>("Name");
+
+                    b.Property<float>("Radius");
+
+                    b.Property<float>("X");
+
+                    b.Property<float>("Y");
+
+                    b.Property<float>("Z");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FactionId");
+
+                    b.ToTable("Doors");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.DutyCloth", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ClothId");
+
+                    b.Property<int>("FactionId");
+
+                    b.Property<bool>("Gender");
+
+                    b.Property<int>("SlotId");
+
+                    b.Property<byte>("SlotType");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FactionId");
+
+                    b.ToTable("DutyClothes");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Faction", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(32);
+
+                    b.Property<bool>("StateOwned");
+
+                    b.Property<int>("WeaponDealTime");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Factions");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.FactionBankAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("Balance");
+
+                    b.Property<string>("Bic")
+                        .HasMaxLength(12);
+
+                    b.Property<int>("FactionId");
+
+                    b.Property<string>("Iban")
+                        .HasMaxLength(32);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FactionId");
+
+                    b.ToTable("FactionBankAccounts");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.FactionRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("FactionId");
+
+                    b.Property<int>("Order");
+
+                    b.Property<string>("RankName");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FactionId");
+
+                    b.ToTable("FactionRanks");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.FactionWeapon", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Ammount");
+
+                    b.Property<int?>("FactionId");
+
+                    b.Property<int>("Rank");
+
+                    b.Property<int>("SlotID");
+
+                    b.Property<string>("WeaponModel");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FactionId");
+
+                    b.ToTable("FactionWeapons");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.GotoPoint", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(32);
+
+                    b.Property<float>("X");
+
+                    b.Property<float>("Y");
+
+                    b.Property<float>("Z");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GotoPoints");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Group", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Groups");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.GroupBankAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Balance");
+
+                    b.Property<int?>("GroupId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("GroupBankAccounts");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.House", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("CanRentIn");
+
+                    b.Property<int?>("OwnerId");
+
+                    b.Property<int>("Price");
+
+                    b.Property<int>("RentalFee");
+
+                    b.Property<string>("Type");
+
+                    b.Property<float>("X");
+
+                    b.Property<float>("Y");
+
+                    b.Property<float>("Z");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("Houses");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.HouseRental", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int?>("HouseId");
+
+                    b.Property<int?>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HouseId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("HouseRentals");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Interior", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("EnterPositionStr")
+                        .HasColumnName("EnterPosition");
+
+                    b.Property<string>("ExitPositionStr")
+                        .HasColumnName("ExitPosition");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Interiors");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Location", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Description");
+
+                    b.Property<double>("Heading");
+
+                    b.Property<double>("X");
+
+                    b.Property<double>("Y");
+
+                    b.Property<double>("Z");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Logs.BankAccountTransactionHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Fee");
+
+                    b.Property<int>("MoneySent");
+
+                    b.Property<int>("NewReceiverBalance");
+
+                    b.Property<int>("NewSenderBalance");
+
+                    b.Property<string>("Origin")
+                        .HasMaxLength(32);
+
+                    b.Property<string>("Receiver")
+                        .HasMaxLength(32);
+
+                    b.Property<int>("ReceiverBalance");
+
+                    b.Property<string>("Sender")
+                        .HasMaxLength(32);
+
+                    b.Property<int>("SenderBalance");
+
+                    b.Property<DateTime>("Timestamp")
+                        .ValueGeneratedOnAdd();
+
+                    b.HasKey("Id");
+
+                    b.ToTable("BankAccountTransactionLogs");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Logs.Death", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("CauseOfDeath")
+                        .HasMaxLength(64);
+
+                    b.Property<float>("KillerHeading");
+
+                    b.Property<int?>("KillerId");
+
+                    b.Property<float>("KillerPositionX");
+
+                    b.Property<float>("KillerPositionY");
+
+                    b.Property<float>("KillerPositionZ");
+
+                    b.Property<DateTime>("Timestamp")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<float>("VictimHeading");
+
+                    b.Property<int>("VictimId");
+
+                    b.Property<float>("VictimPositionX");
+
+                    b.Property<float>("VictimPositionY");
+
+                    b.Property<float>("VictimPositionZ");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("KillerId");
+
+                    b.HasIndex("VictimId");
+
+                    b.ToTable("DeathLogs");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.News", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<string>("Caption");
+
+                    b.Property<string>("Content");
+
+                    b.Property<int>("Timestamp");
+
+                    b.Property<int?>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("News");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Saves.SavedBlip", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<byte>("Alpha");
+
+                    b.Property<byte>("Color");
+
+                    b.Property<byte>("Dimension");
+
+                    b.Property<float>("DrawDistance");
+
+                    b.Property<string>("Name");
+
+                    b.Property<float>("PositionX");
+
+                    b.Property<float>("PositionY");
+
+                    b.Property<float>("PositionZ");
+
+                    b.Property<float>("Rotation");
+
+                    b.Property<float>("Scale");
+
+                    b.Property<bool>("ShortRange");
+
+                    b.Property<short>("Sprite");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Blips");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Saves.SavedMarker", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<byte>("ColorA");
+
+                    b.Property<byte>("ColorB");
+
+                    b.Property<byte>("ColorG");
+
+                    b.Property<byte>("ColorR");
+
+                    b.Property<byte>("Dimension");
+
+                    b.Property<float>("DirectionX");
+
+                    b.Property<float>("DirectionY");
+
+                    b.Property<float>("DirectionZ");
+
+                    b.Property<float>("PositionX");
+
+                    b.Property<float>("PositionY");
+
+                    b.Property<float>("PositionZ");
+
+                    b.Property<float>("RotationX");
+
+                    b.Property<float>("RotationY");
+
+                    b.Property<float>("RotationZ");
+
+                    b.Property<float>("Scale");
+
+                    b.Property<byte>("Type");
+
+                    b.Property<bool>("Visible");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Markers");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Saves.SavedPed", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<byte>("Dimension");
+
+                    b.Property<string>("HashModel");
+
+                    b.Property<float>("Heading");
+
+                    b.Property<float>("PositionX");
+
+                    b.Property<float>("PositionY");
+
+                    b.Property<float>("PositionZ");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Peds");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Saves.SavedPickup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<byte>("Dimension");
+
+                    b.Property<float>("PositionX")
+                        .HasMaxLength(128);
+
+                    b.Property<float>("PositionY");
+
+                    b.Property<float>("PositionZ");
+
+                    b.Property<int>("RespawnTime");
+
+                    b.Property<float>("RotationX");
+
+                    b.Property<float>("RotationY");
+
+                    b.Property<float>("RotationZ");
+
+                    b.Property<bool>("Vehicle");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Pickups");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Saves.SavedTextLabel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<byte>("ColorA");
+
+                    b.Property<byte>("ColorB");
+
+                    b.Property<byte>("ColorG");
+
+                    b.Property<byte>("ColorR");
+
+                    b.Property<byte>("Dimension");
+
+                    b.Property<float>("DrawDistance");
+
+                    b.Property<byte>("Font");
+
+                    b.Property<bool>("LOS");
+
+                    b.Property<float>("PositionX");
+
+                    b.Property<float>("PositionY");
+
+                    b.Property<float>("PositionZ");
+
+                    b.Property<string>("Text")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TextLabels");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.ServerVehicle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active")
+                        .ValueGeneratedOnAdd()
+                        .HasDefaultValue(true);
+
+                    b.Property<string>("Discriminator")
+                        .IsRequired();
+
+                    b.Property<float>("DistanceDriven");
+
+                    b.Property<float>("Heading");
+
+                    b.Property<int>("Livery");
+
+                    b.Property<bool>("Locked");
+
+                    b.Property<uint>("Model");
+
+                    b.Property<string>("NumberPlate")
+                        .HasMaxLength(8);
+
+                    b.Property<float>("PositionX");
+
+                    b.Property<float>("PositionY");
+
+                    b.Property<float>("PositionZ");
+
+                    b.Property<int>("PrimaryColor");
+
+                    b.Property<int>("SecondaryColor");
+
+                    b.Property<float>("TankAmount");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ServerVehicles");
+
+                    b.HasDiscriminator<string>("Discriminator").HasValue("ServerVehicle");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.TuningGarage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<float>("X");
+
+                    b.Property<float>("Y");
+
+                    b.Property<float>("Z");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TuningGarages");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Turfs", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Color");
+
+                    b.Property<int?>("FactionId");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Owner");
+
+                    b.Property<float>("Range");
+
+                    b.Property<float>("Rotation");
+
+                    b.Property<int>("X");
+
+                    b.Property<int>("Y");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Turfs");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AdminLevel");
+
+                    b.Property<int?>("BanId");
+
+                    b.Property<int?>("BusinessId");
+
+                    b.Property<int?>("CharacterId");
+
+                    b.Property<bool>("Dead");
+
+                    b.Property<bool>("DriverLicenseBike");
+
+                    b.Property<bool>("DriverLicenseVehicle");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(64);
+
+                    b.Property<int?>("FactionId");
+
+                    b.Property<bool>("FactionLeader");
+
+                    b.Property<int?>("FactionRankId");
+
+                    b.Property<bool>("FlyingLicensePlane");
+
+                    b.Property<int?>("GroupId");
+
+                    b.Property<int>("GroupRank");
+
+                    b.Property<int>("Handmoney");
+
+                    b.Property<int?>("HouseId");
+
+                    b.Property<int>("JailTime");
+
+                    b.Property<int?>("JobId");
+
+                    b.Property<int>("LogUserId");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(32);
+
+                    b.Property<string>("Password")
+                        .HasMaxLength(64);
+
+                    b.Property<int>("PaydayTimer");
+
+                    b.Property<float>("PositionX");
+
+                    b.Property<float>("PositionY");
+
+                    b.Property<float>("PositionZ");
+
+                    b.Property<DateTime>("RegistrationDate")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("SocialClubName")
+                        .HasMaxLength(32);
+
+                    b.Property<int>("Wage");
+
+                    b.Property<int>("Wanteds");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BanId");
+
+                    b.HasIndex("BusinessId")
+                        .IsUnique();
+
+                    b.HasIndex("CharacterId");
+
+                    b.HasIndex("FactionId");
+
+                    b.HasIndex("FactionRankId");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("HouseId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.UserBankAccount", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Active");
+
+                    b.Property<int>("Balance");
+
+                    b.Property<string>("Bic")
+                        .HasMaxLength(12);
+
+                    b.Property<string>("Iban")
+                        .HasMaxLength(32);
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserBankAccounts");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.UserItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Amount");
+
+                    b.Property<int>("ItemId");
+
+                    b.Property<int>("Slot");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserItems");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.VehicleItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Amount");
+
+                    b.Property<int>("ItemId");
+
+                    b.Property<int>("Slot");
+
+                    b.Property<int>("VehicleId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VehicleId");
+
+                    b.ToTable("VehicleItems");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.VehicleMod", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ModId");
+
+                    b.Property<int>("ServerVehicleId");
+
+                    b.Property<int>("Slot");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ServerVehicleId", "Slot")
+                        .IsUnique();
+
+                    b.ToTable("VehicleMods");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Whitelist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("SocialClubName");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WhitelistEntries");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.FactionVehicle", b =>
+                {
+                    b.HasBaseType("ReallifeGamemode.Database.Entities.ServerVehicle");
+
+                    b.Property<int?>("FactionId");
+
+                    b.HasIndex("FactionId");
+
+                    b.ToTable("FactionVehicles");
+
+                    b.HasDiscriminator().HasValue("FactionVehicle");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.GroupVehicle", b =>
+                {
+                    b.HasBaseType("ReallifeGamemode.Database.Entities.ServerVehicle");
+
+                    b.Property<int?>("GroupId");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("GroupVehicle");
+
+                    b.HasDiscriminator().HasValue("GroupVehicle");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.JobVehicle", b =>
+                {
+                    b.HasBaseType("ReallifeGamemode.Database.Entities.ServerVehicle");
+
+                    b.Property<int>("JobId");
+
+                    b.ToTable("JobVehicle");
+
+                    b.HasDiscriminator().HasValue("JobVehicle");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Saves.SavedVehicle", b =>
+                {
+                    b.HasBaseType("ReallifeGamemode.Database.Entities.ServerVehicle");
+
+
+                    b.ToTable("SavedVehicle");
+
+                    b.HasDiscriminator().HasValue("SavedVehicle");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.SchoolVehicle", b =>
+                {
+                    b.HasBaseType("ReallifeGamemode.Database.Entities.ServerVehicle");
+
+                    b.Property<int>("SchoolId");
+
+                    b.ToTable("SchoolVehicle");
+
+                    b.HasDiscriminator().HasValue("SchoolVehicle");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.ShopVehicle", b =>
+                {
+                    b.HasBaseType("ReallifeGamemode.Database.Entities.ServerVehicle");
+
+                    b.Property<int>("BusinessId");
+
+                    b.Property<int>("Price");
+
+                    b.ToTable("ShopVehicles");
+
+                    b.HasDiscriminator().HasValue("ShopVehicle");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.UserVehicle", b =>
+                {
+                    b.HasBaseType("ReallifeGamemode.Database.Entities.ServerVehicle");
+
+                    b.Property<int>("UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserVehicles");
+
+                    b.HasDiscriminator().HasValue("UserVehicle");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Ban", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.BusRoutePoint", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.BusRoute", "BusRoute")
+                        .WithMany("RoutePoints")
+                        .HasForeignKey("BusRouteId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Character", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.CharacterCloth", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Door", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Faction", "Faction")
+                        .WithMany()
+                        .HasForeignKey("FactionId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.DutyCloth", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Faction", "Faction")
+                        .WithMany()
+                        .HasForeignKey("FactionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.FactionBankAccount", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Faction", "Faction")
+                        .WithMany()
+                        .HasForeignKey("FactionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.FactionRank", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Faction", "Faction")
+                        .WithMany()
+                        .HasForeignKey("FactionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.FactionWeapon", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Faction", "Faction")
+                        .WithMany()
+                        .HasForeignKey("FactionId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.GroupBankAccount", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Group", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.House", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.HouseRental", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.House", "House")
+                        .WithMany()
+                        .HasForeignKey("HouseId");
+
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Logs.Death", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "Killer")
+                        .WithMany()
+                        .HasForeignKey("KillerId");
+
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "Victim")
+                        .WithMany()
+                        .HasForeignKey("VictimId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.News", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.User", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Ban", "Ban")
+                        .WithMany()
+                        .HasForeignKey("BanId");
+
+                    b.HasOne("ReallifeGamemode.Database.Entities.Character", "Character")
+                        .WithMany()
+                        .HasForeignKey("CharacterId");
+
+                    b.HasOne("ReallifeGamemode.Database.Entities.Faction", "Faction")
+                        .WithMany()
+                        .HasForeignKey("FactionId");
+
+                    b.HasOne("ReallifeGamemode.Database.Entities.FactionRank", "FactionRank")
+                        .WithMany()
+                        .HasForeignKey("FactionRankId");
+
+                    b.HasOne("ReallifeGamemode.Database.Entities.Group", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("ReallifeGamemode.Database.Entities.House", "House")
+                        .WithMany()
+                        .HasForeignKey("HouseId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.UserBankAccount", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.UserItem", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.VehicleItem", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.ServerVehicle", "Vehicle")
+                        .WithMany()
+                        .HasForeignKey("VehicleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.VehicleMod", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.ServerVehicle", "Vehicle")
+                        .WithMany()
+                        .HasForeignKey("ServerVehicleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.FactionVehicle", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Faction", "Faction")
+                        .WithMany()
+                        .HasForeignKey("FactionId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.GroupVehicle", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.Group", "Group")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+                });
+
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.UserVehicle", b =>
+                {
+                    b.HasOne("ReallifeGamemode.Database.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/ReallifeGamemode.Database/Migrations/20191129201024_Turfs.cs b/ReallifeGamemode.Database/Migrations/20191129201024_Turfs.cs
new file mode 100644
index 00000000..1be7cde2
--- /dev/null
+++ b/ReallifeGamemode.Database/Migrations/20191129201024_Turfs.cs
@@ -0,0 +1,37 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ReallifeGamemode.Database.Migrations
+{
+    public partial class Turfs : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Turfs",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn),
+                    FactionId = table.Column<int>(nullable: true),
+                    Owner = table.Column<string>(nullable: true),
+                    Name = table.Column<string>(nullable: true),
+                    X = table.Column<int>(nullable: false),
+                    Y = table.Column<int>(nullable: false),
+                    Rotation = table.Column<float>(nullable: false),
+                    Range = table.Column<float>(nullable: false),
+                    Color = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Turfs", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Turfs");
+        }
+    }
+}
diff --git a/ReallifeGamemode.Database/Migrations/DatabaseContextModelSnapshot.cs b/ReallifeGamemode.Database/Migrations/DatabaseContextModelSnapshot.cs
index f001f8c8..f5460add 100644
--- a/ReallifeGamemode.Database/Migrations/DatabaseContextModelSnapshot.cs
+++ b/ReallifeGamemode.Database/Migrations/DatabaseContextModelSnapshot.cs
@@ -890,6 +890,32 @@ namespace ReallifeGamemode.Database.Migrations
                     b.ToTable("TuningGarages");
                 });
 
+            modelBuilder.Entity("ReallifeGamemode.Database.Entities.Turfs", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Color");
+
+                    b.Property<int?>("FactionId");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Owner");
+
+                    b.Property<float>("Range");
+
+                    b.Property<float>("Rotation");
+
+                    b.Property<int>("X");
+
+                    b.Property<int>("Y");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Turfs");
+                });
+
             modelBuilder.Entity("ReallifeGamemode.Database.Entities.User", b =>
                 {
                     b.Property<int>("Id")
diff --git a/ReallifeGamemode.Database/Models/DatabaseContext.cs b/ReallifeGamemode.Database/Models/DatabaseContext.cs
index 4357a23a..12c1c0be 100644
--- a/ReallifeGamemode.Database/Models/DatabaseContext.cs
+++ b/ReallifeGamemode.Database/Models/DatabaseContext.cs
@@ -122,5 +122,8 @@ namespace ReallifeGamemode.Database.Models
     //Driving/Bike/Flight School
     public DbSet<Entities.SchoolVehicle> SchoolVehicles { get; set; }
 
+    //Gangwar
+    public DbSet<Entities.Turfs> Turfs { get; set; }
+
   }
 }
diff --git a/ReallifeGamemode.Server/Events/Login.cs b/ReallifeGamemode.Server/Events/Login.cs
index bc8b5128..404efab3 100644
--- a/ReallifeGamemode.Server/Events/Login.cs
+++ b/ReallifeGamemode.Server/Events/Login.cs
@@ -52,7 +52,7 @@ namespace ReallifeGamemode.Server.Events
             player.SetData("spec", true);
             player.SetData("duty", false);
             player.TriggerEvent("SERVER:SET_HANDMONEY", user.Handmoney, 0);
-
+            Gangwar.Gangwar.loadClient(player);
             if (user.IsAdmin(AdminLevel.HEADADMIN) == true)
             {
               player.SetData("editmode", false);
@@ -102,8 +102,6 @@ namespace ReallifeGamemode.Server.Events
               {
                 Jail.Check_PutBehindBars(player);
               }
-
-
             }
 
             player.TriggerEvent("draw", player.Name, player.Handle.Value);
diff --git a/ReallifeGamemode.Server/Gangwar/Gangwar.cs b/ReallifeGamemode.Server/Gangwar/Gangwar.cs
new file mode 100644
index 00000000..f614bcc5
--- /dev/null
+++ b/ReallifeGamemode.Server/Gangwar/Gangwar.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using GTANetworkAPI;
+using System.Linq;
+using ReallifeGamemode.Database.Models;
+using ReallifeGamemode.Database.Entities;
+using Newtonsoft.Json;
+
+namespace ReallifeGamemode.Server.Gangwar
+{
+  public class Gangwar
+  {
+    public static Turf[] _loadedTurfs;
+    private static List<Turfs> turfs;
+
+    public static void loadTurfs()
+    {
+      _loadedTurfs = null;
+      using (var context = new DatabaseContext())
+      {
+        turfs = context.Turfs.Select(t => t).ToList();
+        List<Turf> turfing = new List<Turf>();
+        foreach (var t in turfs)
+        {
+          Turf newTurf = new Turf(t.Id, t.Name, t.Color, t.Owner);
+          turfing.Add(newTurf);
+        }
+        _loadedTurfs = turfing.ToArray();
+      }
+    }
+
+    public static void loadClient(Client client)
+    {
+      client.TriggerEvent("GangAreas:Create", JsonConvert.SerializeObject(turfs.ToArray()));
+    }
+
+    public Turf[] getTurfs()
+    {
+      return _loadedTurfs;
+    }
+
+  }
+}
diff --git a/ReallifeGamemode.Server/Gangwar/Turf.cs b/ReallifeGamemode.Server/Gangwar/Turf.cs
index 53b36591..aab2f8e9 100644
--- a/ReallifeGamemode.Server/Gangwar/Turf.cs
+++ b/ReallifeGamemode.Server/Gangwar/Turf.cs
@@ -83,11 +83,23 @@ namespace ReallifeGamemode.Server.Gangwar
     {
       Client[] owners = this.playerInside.Where(c => c.GetUser().Faction.Name == this.Owner ).ToArray();
       Client[] attackers = this.playerInside.Where(c => c.GetUser().Faction.Name == this.Attacker).ToArray();
-
+      /*
       if (owners.Length > attackers.Length)
         this.Att_Score -= owners.Length - attackers.Length;
       if(owners.Length < attackers.Length)
         this.Def_Score -= attackers.Length - owners.Length;
+      */
+      foreach (Client playerInArea in this.playerInside)
+      {
+        playerInArea.TriggerEvent("CLIENT:Turf_Update", this.TurfID, this.status, this.Owner, this.Attacker, this.Color, this.Att_Score, this.Def_Score);
+      }
+      if(this.Def_Score <= 0)
+      {
+        this.takeOver(this.Attacker);
+      }else if(this.Att_Score <= 0)
+      {
+        this.takeOver(this.Owner);
+      }
     }
 
     public void enter(Client client)
@@ -107,6 +119,33 @@ namespace ReallifeGamemode.Server.Gangwar
         this.playerInside = this.playerInside.Where(c => c != client).ToArray();
       }
     }
+
+    public void takeOver(string FactionName)
+    {
+      this.timer.Stop();
+      this.timer = null;
+
+
+    }
+
+    public void attack(Client client)
+    {
+      if(this.status == "normal")
+      {
+        if(this.timer != null)
+        {
+          this.timer.Stop();
+          this.timer = null;
+        }
+        this.Attacker = client.GetUser().Faction.Name;
+        this.status = "attack";
+        foreach(Client playerInArea in this.playerInside)
+        {
+          playerInArea.TriggerEvent("CLIENT:Turf_Update", this.TurfID, this.status, this.Owner, this.Attacker, this.Color, this.Att_Score, this.Def_Score);
+        }
+        this.TurfTick();
+      }
+    }
   
   }
 }
diff --git a/ReallifeGamemode.Server/Main.cs b/ReallifeGamemode.Server/Main.cs
index 0026ad7d..66e7a4e6 100644
--- a/ReallifeGamemode.Server/Main.cs
+++ b/ReallifeGamemode.Server/Main.cs
@@ -62,6 +62,7 @@ namespace ReallifeGamemode.Server
       HouseManager.LoadHouses();
       DrivingSchool.DrivingSchool.Setup();
       PlaneSchool.Setup();
+      Gangwar.Gangwar.loadTurfs();
 
       TempBlip tempBlip = new TempBlip()
       {
diff --git a/ReallifeGamemode.Server/Managers/VehicleManager.cs b/ReallifeGamemode.Server/Managers/VehicleManager.cs
index d1af200a..74cd0e43 100644
--- a/ReallifeGamemode.Server/Managers/VehicleManager.cs
+++ b/ReallifeGamemode.Server/Managers/VehicleManager.cs
@@ -723,8 +723,15 @@ namespace ReallifeGamemode.Server.Managers
         Vector3 lastPosition = v.Position;
         if (lastPositions.ContainsKey(v.Handle)) lastPosition = lastPositions[v.Handle];
         lastPositions[v.Handle] = v.Position;
-
-        double distanceDriven = v.HasSharedData("drivenDistance") ? (double)v.GetSharedData("drivenDistance") : 0D;
+        double distanceDriven;
+        try
+        {
+           distanceDriven = v.HasSharedData("drivenDistance") ? (double)v.GetSharedData("drivenDistance") : 0D;
+        }
+        catch(Microsoft.CSharp.RuntimeBinder.RuntimeBinderException ex)
+        {
+           distanceDriven = (double)0;
+        }
 
         double distance = lastPosition.DistanceTo(v.Position) / 1000.0;
         if (distance > 0.2) return;